Transparent Heterogeneous Parallel Async with F#

Posted on January 8, 2014 by Jack Fox

Here’s a strikingly transparent solution to performing parallel Async returning heterogeneous types. Take a look for yourself.

(The solution presented here is based on a gist sent to me by Anton Tayanovskyy, Twitter: @t0yv0.)

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8:

let myInt, myChar, myBool, myString =
    Parallel.Pure (fun w x y z -> (w, x, y, z))
    <*> async { return 1 }
    <*> async { return 'b' }
    <*> async { return true }
    <*> async { return "abc" }
    |> Parallel.Run
    |> Async.RunSynchronously

The custom infix operator clearly maps the parallel operations to the elements of the resulting tuple. That’s it. Done.

The use case I was struggling with involved multiple queries using SqlCommandProvider that the host application could perform in parallel, except SqlCommandProvider returns sequences of records typed to the result of each query, and the Parallel member in Async<'T> requires a consistently typed 'T. Requiring heterogeneously typed responses that the app can perform in parallel is such a common use case I expected a literature search to turn up an appealing solution, but it seemed like authors were ignoring this important case.

You still have to tune it

The project I was working on required 9 asynchronous calls to the SQL Server.¹ Sequentially calling out the queries to the server took 438ms, and this is within an online app, so parallelization is clearly desirable. Packaging-up all 9 queries into the heterogeneous parallelizer resulted in…1,816ms!! Not exactly the result I was looking for. What happened?

The application host workstation had a quad-core processor running @3.60 GHz, but SQL Server was running on an old dual-core server running @2.33 GHz. It seems overloading the maximum number of simultaneous processes, four, on the SQL Server results in a bottleneck that is four times as slow as sequentially processing the 9 queries. A little experimenting with different configurations resulted in these timings:

Configuration	Time
Parallel 9	1,816 ms
Parallel 6-3	751 ms
Sequential 9	438 ms
Parallel 3-3-3	357 ms
Parallel 4-4-1	278 ms
Parallel 4-5	258 ms

For this hardware configuration the sweet spot appears to be matching or overloading by no more than one the number of processes available on the server ² and sequentially executing twice. The moral of the story is to tune the number of parallel Asyncs according to the run environment.

Conceivably if you make calls to different hosts there would be no practical upper bound to the number of Asyncs you could parallelize, but this is not true. Parallel<'T> is using the local host’s thread pool, for which there is some overhead for each additional thread. Also you also might do some local housekeeping within each Async<'T>. In my case that would be instantiating the record sequences from SqlCommandProvider into lists or arrays. As you cross over from IO-bound to CPU-bound tasks, you will have to tune to meet the thread pool constraints on the application host.

Under the hood

It’s important to note Parallel is a helper type and the <*> operator provides a facade over the F# standard library implementation of Async.Parallel, which is where the real work of parallel scheduling is taking place.

Let’s take a look at the full implementation of this clever solution.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48:

type Parallel<'T> =
    private {
        Compute : Async<obj>[]
        Unpack : obj [] -> int -> 'T
    }

    static member ( <*> ) (f: Parallel<'A -> 'B>, x: Parallel<'A>) : Parallel<'B> =
        {
            Compute = Array.append f.Compute x.Compute
            Unpack = fun xs pos ->
                let fv = f.Unpack xs pos
                let xv = x.Unpack xs (pos + f.Compute.Length)
                fv xv
        }

    static member ( <*> ) (f: Parallel<'A ->' B>, x: Async<'A>) : Parallel<'B> =
        f <*> Parallel.Await(x)

and Parallel =

    static member Run<'T> (p: Parallel<'T>) : Async<'T> =
        async {
            let! results =
                match p.Compute.Length with
                | 0 -> async.Return [|box ()|]
                | 1 -> async { let! r = p.Compute.[0] 
                               return [| r |] }
                | _ -> Async.Parallel p.Compute
            return p.Unpack results 0
        }

    static member Await<'T> (x: Async<'T>) : Parallel<'T> =
        {
            Compute =
                [|
                    async {
                        let! v = x
                        return box v
                    }
                |]
            Unpack = fun xs pos -> unbox xs.[pos]
        }

    static member Pure<'T>(x: 'T) : Parallel<'T> =
        {
            Compute = [||]
            Unpack = fun _ _ -> x
        }

Given the signature of Async.Parallel<'T>, seq<Async<'T>> -> Async<'T []>, the only practical way to execute over heterogeneous types is to box them. The innovation of the Parallel type is to make this easy and flexible. Walking through the code execution, the Pure member takes a fully generic function returning a tuple and returns a Parallel typed by that function. Each subsequent useage of the <*> operator and AsyncBuilder returns a new Parallel with the return type of the builder partially applied to the previous function type until strong types have been fully applied and the resulting Parallel is of type the return required strongly typed tuple.

The following illustrates this process (interspersed comments show the state of the let binding if it had ended there):

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18:

let test1 () =
    Parallel.Pure (fun x y z -> (x, y, z))
        // unit -> Parallel<('a -> 'b -> 'c -> 'a * 'b * 'c)>

    <*> async { return 1 }
        // unit -> Parallel<('b -> 'c -> int * 'b * 'c)>

    <*> async { return 'b' }
        // unit -> Parallel<('c -> int * char * 'c)>

    <*> async { return true }
        // unit -> Parallel<int * char * bool>

    |> Parallel.Run
        // unit -> Async<int * char * bool>

    |> Async.RunSynchronously
        // unit -> int * char * bool

As you can tell, there is more complexity involved in eventually returning strongly-typed tuple. I suggest stepping through the debugger for a deeper understanding.

Check out the code in F# Snippets and try running it in Tsunami Cloud by clicking "tsunami.io" from the snippet.

Footnotes

[1] I picked a time of minimal network activity for my testing, resulting in very little variance in my test results. In some cases the average actually coincided with the median. Where they differ I split the difference and report that number. I repeated each test 10 times. The workstation acting as app host and SQL Server are on the same sub-net. Of course repeated calls to the same queries resulted in caching on the server.

[2] This was actually the staging environment of a production system. What a dilemma this presents! Tune for the production system with a 24 core server, resulting in terrible responsiveness in the staging environment ("trust me, QA, this will be fast in production"), or add complexity to the code by implementing different tunings for different environments. I did not test with the production server, but my guess is it would be most efficient to perform all 9 queries in parallel.

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

——————–
type Parallel<'T> =
  private {Compute: Async<obj> [];
           Unpack: obj [] -> int -> 'T;}
  static member ( <*> ) : f:Parallel<('A -> 'B)> * x:Parallel<'A> -> Parallel<'B>
  static member ( <*> ) : f:Parallel<('A -> 'B)> * x:Async<'A> -> Parallel<'B>

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

——————–
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel

Full name: Snippet.Parallel.Parallel<_>

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.Parallel.myInt

val myChar : char

Full name: Snippet.Parallel.myChar

val myBool : bool

Full name: Snippet.Parallel.myBool

val myString : string

Full name: Snippet.Parallel.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel

Full name: Snippet.Parallel<_>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.myInt

val myChar : char

Full name: Snippet.myChar

val myBool : bool

Full name: Snippet.myBool

val myString : string

Full name: Snippet.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

Parallel.Compute: Async<obj> []

Multiple items
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

Full name: Microsoft.FSharp.Control.Async

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Parallel.Unpack: obj [] -> int -> 'T

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

——————–
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

——————–
type int = int32

Full name: Microsoft.FSharp.Core.int

val f : Parallel<('A -> 'B)>

Multiple items
type Parallel =
  static member Await : x:Async<'T> -> Parallel<'T>
  static member Pure : x:'T -> Parallel<'T>
  static member Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel

Full name: Snippet.Parallel<_>

val x : Parallel<'A>

module Array

from Microsoft.FSharp.Collections

val append : array1:'T [] -> array2:'T [] -> 'T []

Full name: Microsoft.FSharp.Collections.Array.append

val xs : obj []

val pos : int

val fv : ('A -> 'B)

Parallel.Unpack: obj [] -> int -> 'A -> 'B

val xv : 'A

Parallel.Unpack: obj [] -> int -> 'A

property System.Array.Length: int

val x : Async<'A>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

Full name: Snippet.Parallel.Run

val p : Parallel<'T>

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val results : obj []

member AsyncBuilder.Return : value:'T -> Async<'T>

val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box

val r : obj

static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>

static member Parallel.Await : x:Async<'T> -> Parallel<'T>

Full name: Snippet.Parallel.Await

val x : Async<'T>

val v : 'T

val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox

static member Parallel.Pure : x:'T -> Parallel<'T>

Full name: Snippet.Parallel.Pure

val x : 'T

val myInt : int

Full name: Snippet.myInt

val myChar : char

Full name: Snippet.myChar

val myBool : bool

Full name: Snippet.myBool

val myString : string

Full name: Snippet.myString

static member Parallel.Pure : x:'T -> Parallel<'T>

val w : int

val x : char

val y : bool

val z : string

static member Parallel.Run : p:Parallel<'T> -> Async<'T>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:System.Threading.CancellationToken -> 'T

val test1 : unit -> int * char * bool

Full name: Snippet.test1

val x : int

val y : char

val z : bool

F# for Functional Enthusiasts Bibliography

Posted on October 2, 2013 by Jack Fox

Bibliograhy and slides for my talk to the Bay Area Clojure User Group .

Type Providers

F# Type Providers

F# R Provider

Visualize World Bank data in R with F# Type Providers

Types, Constraints, and Generics

Engineering Random Bits: F# Generics

The “Designing with types” series

Active patterns and member constraint

Type hackery

Help build optional type systems for Clojure and Clojurescript.

Type system as expressing intent 16:00

Eager Rose Tree, Vector, Parsing, Computational Expressions

Eager Rose Tree

Vector

CrockSolution

TestSandbox

{m}brace demos

Community-Driven Development

The F# Software Foundation

FAKE – F# Make

F# Formatting: Documentation tools

FunScript : F# to JavaScript with type providers

Charting World Bank data with F#

Develop CUDA applications

F# quotations to OpenCL translation

Web client to #websharper channel

Development Alternatives

Tsunami IDE

Missile Command playable in tsunami.io

Configuring Sublime Text 2 To Work With FSharp

Create iOS, Android, Mac and Windows apps

Using Sublime Text 2 as F# REPL

IKVM

IKVM.NET Home Page

Building a Java VM on the .NET Framework

Learning F#

F# Programming

A Course of F# Study

A directory of useful pages

F# Cheatsheet

Visual F#

Coming in F# 3.1

Semantics and List-like Data Structures

Posted on January 5, 2013 by Jack Fox

List as a Semantic Element

The singly-linked list is the fundamental data structure of functional programming. Suspending concern with how it is implemented (forward-linked elements) and dealing with it strictly as an abstract construct of its host language, List is an extension of the programming language, which in turn brings semantic structure to data. Growing and shrinking linear data representations is so powerful List alone suffices for solving a vast number of problems.

Eventually we do need to concern ourselves with implementation. There is a class of purely functional List-like data structures that extend List, either substituting more efficient versions of existing functions or supplementing additional functions for working with linear data representations.

The supplemental List-like data structures derive from familiar structures in imperative programming, but once constructed as purely functional (immutable) data structures, thinking of them as algebraic mutations of List reveals semantic cohesion.

List’s core functionality consists of three functions. (These are the names used in F#, and for clarity I will adhere mostly to the naming standard favored by Okasaki for extension functions, rather than the more familiar function names from imperative programming.)

cons — returns List with new element added to left

head — returns left-most element

tail — returns List excluding left-most element

F# List also provides non-core functionality (again, disregarding implementation you could do without these).

rev — returns reversed List

append — returns List of first List elements followed by second List elements

length — returns count of elements in the List

Extending Serial Representation

The extensions we will consider for our List-like vocabulary:

conj — returns List with new element added to right

initial — returns List excluding right-most element

last — returns right-most element

iLookup — returns element at index

iUpdate — returns List with element at index updated

It is perhaps surprising that List is so useful given that only the most recently added element is accessible! Significantly, you can readily see the extension functions either invert one of the core functions or provide short-cut access to an interior element. RandomAccessList provides indexed lookup and update.

RandomAccessList = List + iLookup + iUpdate

LazyList is one List-like data structure that most probably comes from a functional programming heritage. It is the only List-like structure reviewed here incorporating functionality the core List functions alone cannot replicate, namely lazy evaluation. Significantly in F# it already uses the List-like functional naming standard.

LazyList = List^Lazy

Heap is frequently overlooked as being a List-like data structure. Even Okasaki reverted to using function names from imperative programming that obscure the close relationship to List. Heap is always sorted and provides a more efficient, O(log n), append (merge).

Heap = List + sorted + append

Difference List facilitates adding elements to the other end of the List, whether singly or another entire Difference List in O(1) time.

DList = List + conj + append

After introducing adding elements to both ends, now consider the fully symmetrical linear representation provided by a Double-ended Queue. Deque is the union of its tail and tail’s compliment, initial. This symmetry finds additional expression in an O(1) rev.

Deque = List + conj + last + initial + rev = initial U tail

Queue, a workhorse in imperative programming, is simply a List that can only add elements on the right, but still extracts them on the left with head.

Queue = List - cons + conj

While the algebra deriving Vector from List is the longest, it is simply an inverted RandomAccessList.

Vector = List - cons - head - tail + conj + last + initial + iLookup + iUpdate
Vector = RandomAccessList^-1

Why the Cacophony of Names?

Perhaps perfect computer language implementations are an unrealizable ideal, but consistent nomenclature reveals semantics otherwise easily overlooked. Data structures from imperative programming take on a new character when made purely functional, and it is appropriate for them to give up part of their former identity (function names) in the functional realm.

All of the these F# Data Structures and more are available in the FSharpx.Collections and FSharpx.Datastructures namespaces here or from Nuget in FSharpx.Core.

UPDATE: Updated to naming standard adopted in FSharpx.Collections.

craftyThoughts

Composability -> Expressiveness -> Correctness -> Testability -> Intention

Category Archives: Uncategorized

Transparent Heterogeneous Parallel Async with F#

You still have to tune it

Under the hood

Footnotes

F# for Functional Enthusiasts Bibliography

Type Providers

Types, Constraints, and Generics

Eager Rose Tree, Vector, Parsing, Computational Expressions

Community-Driven Development

Development Alternatives

IKVM

Learning F#

Semantics and List-like Data Structures

List as a Semantic Element

Extending Serial Representation

Why the Cacophony of Names?