Using average as an example of using a tuple-like, but mutable, value
type to tie the data closer together and avoid allocation.

…duce, last, trylast

cleanup for Seq.iter, fold

Also moves the functions in the seq.fsi file to be alphabetical

Processed 1 past the end of the data, as demo'd here:

seq {  for i = 1 to 5 do yield i
failwith "boom" }
|> Seq.pick (fun x -> if x = 5 then Some true else None)
|> fun result -> assert result

Error seen with

seq {  for i = 1 to 5 do yield i
failwith "boom" }
|> Seq.find (fun x -> x = 5)
|> fun result -> assert (result=5)

The following caused an exception, when it shouldn't:

[1;2;3]
|> Seq.take 100
|> Seq.takeWhile (fun _ -> false)
|> Seq.iter (fun _ -> ())

I'm not 100% happy with how I'm allocating ids, nor really with the
added ceremony of the solution, but I think the idea of how to resolve
is basically the right one.

- Shrank public interface by removing ISeqPipeline from ForEach.
- Renamed haltingIdx to pipelineDepth
- Removed haltingIdx from where I could

- Changed "depth" to "idx" to better communicate the function

Pushed the chaining functionality into the interface and added extra
methods on SeqConsumer. This means the consumer can ignore the interface
and just implement their version, which means less likely to be an issue
of the message not being chained correctly.

It also has the advantage that in the object expressions we don't have
to cast back to the base type, which was a potentital area for errors.

Still playing around, happy for some input here...

Bit faster on 64 bit, as don't need to access the ref of e2ok

- made SeqEnumerable<> into an interface (ISeq<>)
- made SeqComponentFactory<> into an interface (ISeqFactory<>)

In the Composer module we use ISeq rather than seq. An end goal could be
be publicly expose this module for enhanced performancy.

Names are unique and descriptive enough

Adding the types doesn't work. Only appearing in portable build, so
pondering if it is a compiler bug? Will need to get onto someone about
it I think.

- removed ref vars, as can just us let mutable
- renamed variables to more meaningful names
- removed modulus because I can

Probably shouldn't be exposed in that manor in the first place, but
secondly they caused a error in ci_part1. Used this as a chance to
rename the module as well.

Due to the change in the inline functions within Seq (i.e. sum etc.)
there are significant changes within this file.

Unit tests check that the item call object the lazy nature of the
Seq.init

- Still hidden via internal module
- simplified PipeIdx, no need for optional now
- Made ISeqFactory an abstract class instead of interface so as not to
require a stub implementation of PipeIdx in every object expression (or
alternatively if the abstract class was used with the interface, then
explicit declaration of the interface as well)
- filter and map changed to inline versions

passing a reference as an argument in a funciton stops the F# compiler
from outputting a tail instruction for that function.  None of these
functions will be significantly deep as to warrant the need for a tail
call.

- added a mapi_adapt version for non-inlined

- Removed all dynamic casting
- Split enumerable/enumerator
- Implementations of map, filter, skip, pairwise

- Added take, mapi
- Added same exceptions for skip & take
- Added composable skip & take
- Added array source
- Added source specific folding for functions like sum (required growing
of surface area, so currently not exposed)

It was causing build issues as it was currently unused.

*slight* performance improvement

Thanks to @liboz for reminding me of the performance hit here. This is
noticeable when you have small collections to be iterated.

A more direct calling process. Slows things down *slightly* when only a
single item is being processed, but is a better model to build from
going forward.

Due to the bottom-up build process I now have a consistent output
signature, which allowed it to be wrapped in an single object rather
than being passed up and down the chain of ProcessNext calls.

Retained MoveNext in derived class to ensure we didn't add an extra
virtual call into the call stack.

Sweeping up common functionality

Not as simple as it should be due to the original implementation
deciding to evaluate Current in a lazy fashion. Comments have been
splattered around hopefully describing the situation in enough detail.

The plan is to then implement fold like functionality in a Tail like
object that we can expose out in a public interface, so I'm trying to
minimize what would be needed to be visible externally.

I probably don't have any more time today to bug issues

Try again, without any other clutter

Hmmm... not 100% happy with this because it requires all links in the
chain to ensure that that follow the protocol, but it isn't too bad I
guess...

This implemention performs vastly better than the previous
implementation, which appeared to be more interested in being
theoretically important than actually being a reasonable implementation.
Anyway, the previous version blew up with stack overflow if you appended
too many things, which the new version doesn't.

This is retained for compatibility

- better comments
- consistent casing

- removing the check of both types

Identity can be used to wrap basic containers into SeqComposer
compatible types, but can safely be removed when composing the
components.

Also removed some extra null checks