Resources, AsyncSeq, Try Finally and possible alternative definitions about fsharp.control.asyncseq HOT 6 CLOSED

/// An async pipeline which consumes values of type 'i, produces
/// values of type 'o and completes with a result 'a or an error.
type AsyncPipe<'i, 'o, 'a> = Async<AsyncPipeStep<'i, 'o, 'a>>

/// An individual step in an async pipeline.
and AsyncPipeStep<'i, 'o, 'a> =

  /// The pipeline completed with result 'a.
  | Done of 'a

  /// The pipeline is emitting a value of type 'o.
  | Emit of 'o * AsyncPipe<'i, 'o, 'a>

  /// The pipeline is consuming a value of type 'i.
  | Await of ('i option -> AsyncPipe<'i, 'o, 'a>)

type AsyncSeq<'T> = Async<AsyncSeqInner<'T> * (unit -> unit)> 

and AsyncSeqInner<'T> = 
  | Nil
  | Cons of 'T * AsyncSeq<'T>


type Async with
  static member map f a = async.Bind(a, f >> async.Return)
  static member bind f a = async.Bind(a, f)


let empty<'T> : AsyncSeq<'T> = async.Return(Nil,id)

let singleton (item:'T) : AsyncSeq<'T> =
  async.Return(Cons(item,empty),id)

let rec tryFinally (s:AsyncSeq<'T>) (comp:unit -> unit) : AsyncSeq<'T> = async {
  try
    let! s = s
    match s with
    | Nil,comp' -> return Nil,(comp' >> comp)
    | Cons(a,tl),comp' -> return Cons(a,tryFinally tl comp),(comp' >> comp)
  with ex ->
    comp()
    return raise ex }

let rec append (f:AsyncSeq<'T>) (s:AsyncSeq<'T>) : AsyncSeq<'T> =
  f |> Async.bind (function
    | Nil,comp -> tryFinally s comp
    | Cons(a,tl),comp -> (Cons(a, append tl s),comp) |> async.Return)

let rec collect (f:'T -> AsyncSeq<'U>) (s:AsyncSeq<'T>) : AsyncSeq<'U> =
  s |> Async.bind (function
    | Nil,comp -> (Nil,comp) |> async.Return
    | Cons(a,tl),comp -> async { 
      return! append (f a) (collect f tl)
    })

let rec iterAsync (f:'T -> Async<unit>) (s:AsyncSeq<'T>) : Async<unit> =
  s |> Async.bind (function
    | Nil,comp -> async { comp() }
    | Cons(a,tl),comp -> async {
      try
        do! f a
        return! iterAsync f tl 
      with ex ->
        comp()
        return raise ex
    })

let rec ofList (ls:'T list) : AsyncSeq<'T> =
  match ls with
  | [] -> (Nil,id) |> async.Return
  | hd::tl -> (Cons(hd, ofList tl),id) |> async.Return

let rec take (count:int) (s:AsyncSeq<'T>) : AsyncSeq<'T> =
  s |> Async.map (function
    | Nil,comp -> Nil,comp
    | Cons(a,tl),comp ->
      if count = 0 then Nil,comp
      else Cons(a, take (count - 1) tl),comp)

type AsyncSeqBuilder() =
  member x.Yield(v) = singleton v
  member x.Return(()) = empty
  member x.YieldFrom(s) = s
  member x.Zero () = empty
  member x.Bind (inp:Async<'T>, body : 'T -> AsyncSeq<'U>) : AsyncSeq<'U> = 
    async.Bind(inp, body)
  member x.Combine (seq1:AsyncSeq<'T>,seq2:AsyncSeq<'T>) = 
    append seq1 seq2
  member x.While (gd, seq:AsyncSeq<'T>) = 
    if gd() then x.Combine(seq,x.Delay(fun () -> x.While (gd, seq))) else x.Zero()
  member x.Delay (f:unit -> AsyncSeq<'T>) = 
    async.Delay(f)
  member x.Using (resource:#IDisposable, binder) = 
    tryFinally (binder resource) (fun () -> 
      if box resource <> null then resource.Dispose())
  member x.TryFinally (body: AsyncSeq<'T>, compensation) = 
    tryFinally body compensation   

let asyncSeq = new AsyncSeqBuilder()

let printer() = printfn "allocate"; { new System.IDisposable with member __.Dispose() = printfn "disposed" }
let a = 
    asyncSeq { use _d = printer()
               yield 1
               yield 2 }

a |> take 1 |> iterAsync (fun _ -> async.Return()) |> Async.RunSynchronously