Module with basic functions for working with IEnumerator

 1: module Enumerator = 
 2: 
 3:   let single a = 
 4:     let state = ref 0
 5:     { new IEnumerator<_> with 
 6:         member self.Current = if (state.Value = 1) then a else invalidOp "!"
 7:       interface System.Collections.IEnumerator with
 8:         member self.Current = if (state.Value = 1) then box a else invalidOp "!"
 9:         member self.MoveNext() = state := state.Value + 1; state.Value = 1
10:         member self.Reset() = state := 0
11:       interface System.IDisposable with 
12:         member self.Dispose() = ()}
13: 
14:   let combine (a:IEnumerator<_>) b = 
15:     let current = ref a
16:     let first = ref true
17:     { new IEnumerator<_> with 
18:         member self.Current = current.Value.Current
19:       interface System.Collections.IEnumerator with
20:         member self.Current = box current.Value.Current
21:         member self.MoveNext() = 
22:           if current.Value.MoveNext() then true 
23:           elif first.Value then 
24:             current := b
25:             first := false
26:             current.Value.MoveNext()
27:           else false
28:         member self.Reset() = 
29:           a.Reset(); b.Reset()
30:           first := true; current := a
31:       interface System.IDisposable with 
32:         member self.Dispose() = a.Dispose(); b.Dispose() }
33:   
34:   let zero () = 
35:     { new IEnumerator<_> with 
36:         member self.Current = invalidOp "!"
37:       interface System.Collections.IEnumerator with
38:         member self.Current = invalidOp "!"
39:         member self.MoveNext() = false
40:         member self.Reset() = ()
41:       interface System.IDisposable with 
42:         member self.Dispose() = ()}
43:   
44:   let delay f = 
45:     let en : Lazy<IEnumerator<_>> = lazy f()
46:     { new IEnumerator<_> with 
47:         member self.Current = en.Value.Current
48:       interface System.Collections.IEnumerator with
49:         member self.Current = box en.Value.Current
50:         member self.MoveNext() = en.Value.MoveNext()
51:         member self.Reset() = en.Value.Reset()
52:       interface System.IDisposable with 
53:         member self.Dispose() = en.Value.Dispose() }
54: 
55:   let toSeq gen = 
56:     { new IEnumerable<'T> with 
57:           member x.GetEnumerator() = gen() 
58:       interface IEnumerable with 
59:           member x.GetEnumerator() = (gen() :> IEnumerator) }

Computation builder for working with enumerators

 1: type EnumerableBuilder() = 
 2:   member x.Delay(f) = Enumerator.delay f
 3:   member x.YieldFrom(a) = a
 4:   member x.Yield(a) = Enumerator.single a
 5:   member x.Bind(a:IEnumerator<'a>, f:_ -> IEnumerator<'b>) =
 6:     if (a.MoveNext()) then f (Some(a.Current)) else f(None) 
 7:   member x.Combine(a, b) = Enumerator.combine a b
 8:   member x.Zero() = Enumerator.zero ()
 9: 
10: let iter = new EnumerableBuilder()    

Examples of using 'iter' computations

 1: // Enumerator that produces 3 numbers
 2: let e = iter { yield 1; yield 2; yield 3 }
 3: e.MoveNext()
 4: e.Current
 5: 
 6: // Enumerator that iumplements "identity" and prints elements
 7: let rec loop e = iter {
 8:   let! v = e
 9:   printfn "%A" v
10:   yield v
11:   yield! loop e }
12:   
13: let e2 = iter { yield 1; yield 2; yield 3 }
14: let r = loop e2
15: 
16: r.MoveNext()
17: r.Current
18: 
19: // Implementing the zip function for enumerators
20: let rec zipE xs ys = iter {
21:   let! x = xs
22:   let! y = ys
23:   match x, y with 
24:   | Some(x), Some(y) ->
25:     yield x, y
26:     yield! zipE xs ys 
27:   | _ -> () }
28: 
29: // Implementing zip for sequences using zip for enumerators
30: let zip (a:seq<_>) (b:seq<_>) = 
31:   Enumerator.toSeq (fun () -> 
32:     zipE (a.GetEnumerator()) (b.GetEnumerator()))
33: 
34: zip [1;2;3] ["a";"b";"c"]
35: zip [1;2;3;4] ["a";"b";"c"]