HopacSamples.fsx

#time
#r @"..\packages\Hopac\lib\net45\Hopac.Core.dll"
#r @"..\packages\Hopac\lib\net45\Hopac.dll"
#r @"..\packages\Hopac\lib\net45\Hopac.Platform.dll"

open Hopac
open Hopac.Infixes

let t label f = 
    let sw = System.Diagnostics.Stopwatch.StartNew ()
    let r = f ()
    printfn "[%s] done in %ims" label sw.ElapsedMilliseconds
    System.GC.Collect()
    System.GC.WaitForPendingFinalizers ()
    r

module ParListHopac = 
    let rec fib n = 
        job { 
            if n < 2L then return n
            else 
                let! r = [fib (n - 2L);fib (n - 1L)] |> Job.seqCollect

                return r |> Seq.sum }

module ParHopac = 
    let rec fib n = 
        job { 
            if n < 2L then return n
            else let! (x, y) = fib (n - 2L) <*> fib (n - 1L)
                 return x + y }

module ParAsc = 
    let rec fib n = 
        async {
            if n < 2L then return n
            else
                let! x = fib (n - 2L) |> Async.StartChild
                let! y = fib (n - 1L)
                let! x = x
                return x + y }
module SeqAsc = 
    let rec fib n = 
        async {
            if n < 2L then return n
            else
                let! x = fib (n - 2L) 
                let! y = fib (n - 1L)
                return x + y }

module SeqAscHop = 
    let fib n = SeqAsc.fib n |> Job.fromAsync

module ParHopAsc = 
    let fib n = ParHopac.fib n |> Job.toAsync


//~100ms
t "ParHopac" <| fun () -> ParHopac.fib 30L |> Hopac.run
//~100ms
t "ParHopAsc" <| fun () -> ParHopAsc.fib 30L |> Async.RunSynchronously

//~410ms
t "SeqAscHop" <| fun () -> SeqAscHop.fib 30L |> Hopac.run
//~410ms
t "SeqAsc" <| fun () -> SeqAsc.fib 30L |> Async.RunSynchronously

t "ParListHopac" <| fun () -> ParListHopac.fib 30L |> run

t "ParAsc" <| fun () -> ParAsc.fib 30L |> Async.RunSynchronously

Thank you. But how can I convert async to hopac without big refactoring or hiding Async builder?