hyper/race semantics

	A	B	C	D	E
1	Key
2		Terminates parallel and list processing (result is item, hash, Supply, etc.)
3		Terminates parallel processing, resulting in a sequential Seq or List
4		Remains/continues in hyper paradigm
5		Remains/continues in race paradigm
6
7	Operation	Semantics of hyper	Done/Tested	Semantics of race	Done/Tested
8	AT-POS	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
9	Array	Makes an Array from the sequential iterator	Needs tests	Makes an Array from the sequential iterator	Needs tests
10	Bag	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
11	BagHash	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
12	Bool	Delegated to .cache		Delegated to .cache
13	EXISTS-POS	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
14	Hash	Defined as .hash.Hash	Needs tests	Defined as .hash.Hash	Needs tests
15	Int	Delegated to .cache		Delegated to .cache
16	List	Makes a List from the sequential iterator	Needs tests	Makes a List from the sequential iterator	Needs tests
17	Map	Defined as .hash.Map	Needs tests	Defined as .hash.Map	Needs tests
18	Mix	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
19	MixHash	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
20	Numeric	Delegated to .cache		Delegated to .cache
21	Set	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
22	SetHash	Defined in terms of .list	Needs tests	Defined in terms of .list	Needs tests
23	Slip	Makes a Slip from the sequential iterator	Needs tests	Makes a Slip from the sequential iterator	Needs tests
24	Str	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
25	Stringy	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
26	Supply	Produces a serial Supply, with values emitted as they are produced. May be revisited when we have `hyper whenever $s { ... }` semantics clear.)		Produces a non-serial Supply, with values emitted as they are produced. (Note that most things that process supplies will enforce serial processing.) May be revisited when we have `race whenever $s { ... }` semantics clear.
27	all	Defined in terms of .eager	Needs tests	Defined in terms of .eager	Needs tests
28	antipairs	Same as .pairs but with key/value flipped		Same as .pairs but with key/value flipped
29	any	Defined in terms of .eager	Needs tests	Defined in terms of .eager	Needs tests
30	batch	Groups input items into groups of the specified size, which respect the input order. Downstream operations can process these batches in parallel.		Groups input items into groups of the specified size, based on the order that the items become available from the preceding operation. Thus the order of the batches and the items inside the batches may be disordered with regard to the input.
31	cache	Makes a List from the sequential iterator and saves it	Needs tests	Makes a List from the sequential iterator and saves it	Needs tests
32	categorize	May call the mapper in parallel; result arrays ordered relative to input items		May call the mapper in parallel; item order in result arrays may not respect input order
33	classify	May call the mapper in parallel; result arrays ordered relative to input items		May call the mapper in parallel; item order in result arrays may not respect input order
34	collate	Defined in terms of .sort		Defined in terms of .sort
35	combinations	Equivalent to .list.combinations(...).hyper, except it may internally work in parallel to produce the combinations		Equivalent to .list.combinations(...).race, except it may internally work in parallel to produce the combinations
36	deepmap	Semantics as with Seq.deepmap, producing a List, but the operation may be applied to values and sublists in parallel.		Semantics as with Seq.deepmap, producing a List, but the operation may be applied to values and sublists in parallel and the order of results at both the top level and in sublists is undefined.
37	duckmap	Semantics as with Seq.duckmap, producing a List, but the operation may be applied to values and sublists in parallel.		Semantics as with Seq.duckmap, producing a List, but the operation may be applied to values and sublists in parallel and the order of results at both the top level and in sublists is undefined."
38	eager	Defined as .List.eager	Needs tests	Defined as .List.eager	Needs tests
39	elems	Delegated to .cache	Done, tested	Delegated to .cache	Done, tested
40	end	Delegated to .list		Delegated to .list
41	first	Applies predicate in parallel, but must return the first found item with respect to input order; predicate may be applied to items beyond that which matches		Applies predicate in parallel; returns first matching item regardless of input order. Predicate may be applied and match on items other than the one that is returned.
42	flat	May flatten (and so evaluate) sublists in parallel, but order of both input lists and sublists is retained		May flatten (and so evaluate) sublists in parallel; elements from different sublists being flattened in may become interleaved
43	flatmap	Defined as .map(...).flat		Defined as .map(...).flat
44	fmt	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
45	gist	Delegated to .cache	Needs tests	Delegated to .cache	Needs tests
46	grep	Applies predicate in parallel. Outputs matching items with respect to input order.	No phaser or controls support	Applies predicate in parallel. Outputs matching items as they are found, maybe dis-ordering them	No phaser or controls support
47	hash	Defined in terms of .iterator.		Defined in terms of .iterator, which disordered values relative to their inputs. This is unprobelamtic if the results are Pairs; beware of keys/values.
48	head	The first item produced, relative to the order of the input items.		The first item produced, without any regard to the order of the inputs. Effectively, an item that was quick to produce.
49	head(N)	The first N items produced, relative to the order of the input items. It is possible elements from the input beyond those resulting in values being returned will be processed.		The first N items produced by the computation, without any regard to the order of the inputs. Useful when you need N results, and those produced soonest are good enough.
50	hyper	Identity	Done, tested	Makes any following operations respect ordering	Done, tested
51	invert	Defined as .map(-> Pair $p { $p.value => $p.key })		Defined as .map(-> Pair $p { $p.value => $p.key })
52	is-lazy	Returns False	Done, tested	Returns False	Done, tested
53	iterator	Ends parallel pipeline; will get values relative to input order	Needs tests	Ends parallel pipeline; will get values in the produced order	Needs tests
54	join	Defined in terms of the sequential .iterator. The joined items will be relative to the input order, and sub-parts may be joined in parallel.		Defined in terms of the sequential .iterator. Thus the joined items will be in the order produced, and may be disordered with regard to the input computation. Sub-parts may be joined in parallel.
55	keys	Produces a sequence of ascending integers, starting from zero. They are only produced when the input item at that index has been processed.		Produces integers starting from zero and incrementing with each value that is processed. The order of the integers will likely have little useful meaning. Why are you even using this?
56	kv	Produces an alternating sequence of ascending integers and values.		Defined as .hyper.kv, since otherwise the integers would potentially soon end up scattered any old way among the values. Note that unless this is the first item in the parallel pipeline, the data may already have been disordered. If it's the first, then the .race should have been .hyper in the first place.
57	lazy	Defined in terms of the sequential .iterator		Defined in terms of the sequential .iterator
58	lazy-if	Defined in terms of .lazy		Defined in terms of .lazy
59	list	Makes a List from the sequential iterator	Done, tested	Makes a List from the sequential iterator	Done, tested
60	map	Applies the mapping in parallel. Produces output relative to input order. Respects Slips.	No phaser or controls support	Applies the mapping in parallel. Outputs may be disordered relative to inputs. Items inserted by a Slip will be together in the direct output, but may be disordered by further operations under the race paradigm.	No phaser or controls support
61	max	Performs comparisons in parallel on items as they become available, producing the maximum value.		Performs comparisons in parallel on items as they become available, producing the maximum value.
62	maxpairs	Produces results equivalent to Seq.maxpairs; comparisons may be done in parallel		Produces results equivalent to Seq.maxpairs; comparisons may be done in parallel
63	min	Performs comparisons in parallel on items as they become available, producing the minimum value.		Performs comparisons in parallel on items as they become available, producing the minimum value.
64	minmax	Results as with Seq.minmax, but may call &by in parallel		Results as with Seq.minmax, but may call &by in parallel
65	minpairs	Produces results equivalent to Seq.minpairs; comparisons may be done in parallel		Produces results equivalent to Seq.minpairs; comparisons may be done in parallel
66	nodemap	Semantics as with Seq.nodemap, producing a List, but the operation may be applied in parallel.		Semantics as with Seq.nodemap, producing a List, but the operation may be applied in parallel and the results may be disordered relative to the inputs.
67	none	Defined in terms of .eager	Needs tests	Defined in terms of .eager	Needs tests
68	not	Defined in terms of .Bool		Defined in terms of .Bool
69	one	Defined in terms of .eager	Needs tests	Defined in terms of .eager	Needs tests
70	pairs	Produces pairs mapping the integer index of the item in the input sequence to the item itself.		Produces pairs mapping the integer index of the item in the input sequence to the item itself. Unless this is the very first operation in the parallel chain, the integers will have no particular relation to the original input order. If it is, then this may be useful in that it allows you to retain the original positions of items while processing them in any order. But in most cases, it would have been better to just use .hyper.
71	pairup	Equivalent to .batch(2).map({ .[0] => .[1] })		Equivalent to .batch(2).map({ .[0] => .[1] }) (noting that the input items may be disordered by prior operations)
72	perl	Delegated to .cache, with .hyper appended		Delegated to .cache, with .race appended
73	permutations	Equivalent to .list.permutations.hyper, except it may internally work in parallel to produce the permutations		Equivalent to .list.permutations.race, except it may internally work in parallel to produce the permutations
74	pick	Delegated to .list		Delegated to .list
75	pick(N)	Must see all values from the previous step in order to start producing results; stays in parallel processing mdoe		Must see all values from the previous step in order to start producing results; stays in parallel processing mdoe
76	produce	Applies the reduction operation to values in order, and so will never call it in parallel. Produces all intermediate results, which may themselves be processed in parallel.		Applies the reduction operation to values in order, and so will never call it in parallel (otherwise it's hard to produce meaningful intermediate results). Since the values will be disordered relative to the inputs, however, it's important that the operation commutes. Further steps in the pipeline will process the produced values in any order.
77	race	Means any following operations need not respect order	Done, tested	Identity	Done, tested
78	reduce	Applies the reduction operation to values in order, and so will never call it in parallel. Thus, equivalent to .list.reduce.		Applies the reduction operator in parallel to batches, and then further reduces those to a single result. The reduction operator may thus run in parallel, and the result will only make sense if it is commutative.
79	repeated	Emits values that value already been seen. May execute &as or &with in parallel.		Defined as .hyper.repeated (e.g. switches on ordering for following operations)
80	reverse	Emits items in reverse order relative to the input order. Keeps processing in the hyper paradigm.		Identity result, together with a warning. (The items are not ordered, and so there's no useful use for reverse here.)
81	roll	Delegated to .list		Delegated to .list
82	roll(N)	Must see all values from the previous step in order to start producing results; stays in parallel processing mdoe		Must see all values from the previous step in order to start producing results; stays in parallel processing mdoe
83	rotor	Works as with Seq.rotor, except that the results may also be processed in parallel		Works as with Seq.rotor, except the items in the batches and the batches themselves may be produced out of order
84	sink	Blocks until all values have been processed	Done, tested	Blocks until all values have been processed	Done, tested
85	skip	Excludes the first N items from the input		Excludes the first N items produced, without regard to the input order (effectively, excludes any N items)
86	so	Defined in terms of .Bool		Defined in terms of .Bool
87	sort	May invoke the sort criteria in parallel, and work internally in parallel.		Defined as .hyper.sort (e.g. switches on ordering for following operations)
88	squish	May invoke the as/with in parallel. Works by squishing batches of values in parallels, then further squishing at the boundaries, meaning the &as may be invoked more times than in the sequential case.		Defined as .hyper.squish (e.g. switches on ordering for following operations).
89	sum	Defined in terms of .reduce		Defined in terms of .reduce
90	tail	Gets the final item produced, relative to the input items.		Gets the final item produced; since this is unordered, it could be any item.
91	tail(N)	Gives the final N items produced, which will be ordered relative to the inputs.		Gives the last N items that are produced by the parallel pipeline, without regard to input order. Effectively, you can rely on getting any N items, and all input items have been processed.
92	tree	Implemented in terms of .iterator		Implemented in terms of .iterator
93	unique	May invoke the as/with in parallel, and may invoke them more times than the sequential equivalent, depending on implementation.		May invoke the as/with in parallel, and may invoke them more times than the sequential equivalent, depending on implementation.
94	values	Identity		Identity
95
96
97
98
99
100