リスト(シーケンス)用高階関数対応表

	A	B	C	D	E	F	G	H	I	J
1	言語や関数はてきとうに追加してくださいね。	Ruby 1.9.0	C# 4 (LINQ)	Python	Haskell	Scala	F#	C++	C++	Java 8 (Stream)
2	↓この列は備考欄ということにしたい。	Rubyのyieldは内部列挙方式	LINQ (遅延評価)			For Comprehension (遅延評価)	Seq (遅延評価)	Boost.Range (遅延評価)	PStade.Oven (遅延評価)	Stream (遅延評価)

3		all?	All		all	forall	forall	all	forall	allMatch
4		any?	Any		any	exists, contains	exists		exists	anyMatch
5		count	Count/LongCount	count	length	size/length	length	distance	size/distance	count / collect(Collectors.counting())
6		count(elem)			(\x -> length.filter x)			count_if
7		count{\|item\| ... }				count	countBy
8		cycle		cycle		continually			cycled
9		detect	FirstOrDefault			find	find	(filtered)	(filtered)	findFirst
10		drop	Skip		drop	drop	skip		dropped	skip
11		drop_while	SkipWhile	dropwhile	dropWhile	dropWhile	skipWhile		dropped_while
12							pairwise
13		each_cons					windowed
14		each_slice
15		each_with_index			zip [1..]	zipWithIndex.foreach{...}		indexed
16		entries	ToArray			toArray/toList/...	toArray / toList	copy_range	copied	toArray / collect(Collectors.toList())
17		find	FirstOrDefault		find	find	find / tryFind			findFirst
18		find_all	Where		filter	filter, withFilter	filter	filtered	filtered	filter
19		find_index			findIndex	indexOf	findIndex / tryFindIndex
20		first	FirstOrDefault		head	head	head		front	findFirst
21		first(n)	Take		take	take	take / truncate		taken	limit
22		grep	Where						filtered	filter
23		group_by	GroupBy	groupby		groupBy	groupBy			collect(Collectors.groupingBy)
24		include?	Contains		elem	contains
25		map/collect	Select	imap	map	map	map	transformed	transformed, elements, elements_c	map
26			Select			map	mapi
27		max	Max		maximum	max	max			max
28	比較関数を取る	max{\|a, b\| ... }			maximumBy	max				max
29	変換関数を取る	max_by	Max			maxBy	maxBy			collect(Collectors.maxBy)
30		member?	Contains		elem	contains
31		min	Min		minumum	min	min			min
32	比較関数を取る	min{\|a, b\| ... }			minimumBy	min				min
33	変換関数を取る	min_by	Min			minBy	minBy			collect(Collectors.minBy)
34		minmax
35		minmax_by
36		none?	Any		not.or	isEmpty				noneMatch
37		one?	Single			single
38		partition	ToLookup			partition	List.partition / Array.partition		partitioned	collect(Collectors.partitioningBy())
39		reduce/inject	Aggregate		foldl1	reduceLeft	reduce	accumulate		reduce
40			Aggregate		foldl	foldLeft	fold
41							scan
42		reject	Where		(\p -> filter (not.p) )	filterNot
43		select	Where	ifilter	filter	filter, withFilter	filter	filtered	filtered	filter
44		sort	OrderBy		sort	sort(deprecated),sorted	sort		sorted	sorted
45	比較関数を取る						List.sortWith / Array.sortWith			sorted
46	変換関数を取る	sort_by			sortBy	sortBy	sortBy		sorted
47		take	Take		take	take	take / truncate		taken	limit
48		take_while	TakeWhile	takewhile	takeWhile	takeWhile	takeWhile		taken_while
49		to_a	ToArray			toArray	toArray	copy_range	copied, memorized	toArray
50		zip		izip	zip	zip	zip		zipped, fuzipped, zippped_with
51			Zip		zipWith	List.map2(deprecated),zipped.map	map2
52					foldr	foldRight	List.foldBack / Array.foldBack
53					foldr1	reduceRight	List.reduceBack / Array.reduceBack
54		Array#shift			tail
55		concat	Concat	chain	(++)	++	append	join	joined	concat
56		flatten	SelectMany		concat	flatMap	concat		concatenated	flatMap
57			SelectMany		concatMap	flatMap	collect
58		Array.new(size, val)	Repeat	repeat	replicate	fill	init size (fun _ -> val)		generation
59		Range.newまたは範囲演算子	Range		[a..b]	a to b	seq { a..b }	irange	counting	range
60		Array.new(size) {\|index\| ... }				tabulate	init
61					unfold	iterate	unfold		unfold
62						from
63		each				foreach	iter	for_each, BOOST_FOREACH	PSTADE_OVEN_FOREACH	forEach
64							iteri
65		sum	Sum			sum	sum	accumulate		sum
66	変換関数を取る						sumBy			collect(Collectors.summingInt())
67			Average				average			average
68	変換関数を取る						averageBy			collect(Collectors.averagingInt())
69			ElementAt		(!!)	apply	nth		value_at
70		スライス表記？		islice		slice	xs.[a..b] / xs.[a..] / xs.[..b]	sliced, copied	window, offset
71		reverse_each	Array.Reverseほか		reverse	reverse	List.rev / Array.rev	reversed	reversed	Collections.reverse
72		Array#join				mkString	String.concat		delimited	collect(Collectors.joining())
73	tee的なもの								copied_to	peek
74									memorized
75		Array#uniq	Distinct		(map head) . Data.List.group . Data.List.sort	distinct	distinct	uniqued	uniqued	distinct
76		Array#permutation				permutations			permuted
77		each_with_object							scanned
78								adjacent_filtered	adjacent_filtered
79									adjacent_transformed
80									rotated
81									merged
82									set_cap
83									set_cup
84									set_delta
85									set_minus
86		Hash#each_key	IDictionary<TKey, TValue>.Keys			Map[A, +B]#keys		map_keys	map_keys
87		Hash#each_value	IDictionary<TKey, TValue>.Values			Map[A, +B]#values		map_values	map_values
88
89
90
91
92
93
94
95
96
97
98
99
100