A type for execute ahead but consume in order

[harendra-kumar]

We can have a hybrid of SerialT and CoparallelT type called AheadT. The behavior of CoparallelT is to execute a batch of actions at the head of the stream in parallel. The results of these actions may be consumed out of order. The behavior of AheadT would be to execute a batch of actions at the head of the stream in parallel (like CoparallelT) but consume the results in the same order (like SerialT). This means we may execute ahead but maintain the serial order. This is like the concept of readahead or we may call it IOahead. The type combinator for this could be ahead.

[harendra-kumar]

Thinking about more generalized combinators, we perhaps need a better organization scheme for the combinators used to mix streams together. Currently we have these:

• serially
• coserially
• coparallely
• parallely

The following independent dimensions are involved when we mix streams:

1. whether we are going depth first (finish one stream before going to next) or breadth first (yield one element, or some elements, based on numbers or time slice, from one stream and then go to next). For example both serially and interleaving are serial in nature but they differ in DFS or BFS pattern.
2. whether we are executing serially i.e. producing only one element at a time or parallely i.e. producing more than one. This is how serial (serially, coserially) and parallel (coparallely, parallely) types differ from each other.
3. When executing parallely, what is the quantum of parallelism i.e. a few of them on-demand (coparallely) or it can range to all of them in parallel (parallely).
4. When we are executing parallely whether we are yielding elements in the specified order (FIFO) or out of order (FCFS) as they arrive. This is how out-of-order types (coparallely, parallely) and in order types (ahead, coahead) differ.

May be we can design combinators for different dimensions and mix them to create a desired scheme instead of having many canned combinators.

[harendra-kumar]

In fact we need a dual pair of AheadT and CoaheadT. AheadT would execute stream actions in parallel but yield exactly in the same order as SerialT, this is like CoparallelT but yielding in positional order. CoaheadT would execute actions in parallel but yield exactly in the same order as CoserialT, this is like ParallelT but yielding in positional order.

[harendra-kumar]

An Ahead type has been added via 9da3fcc. We also need a corresponding wAhead type for wide (breadth first) traversal with lookahead.

[harendra-kumar]

This is fixed.