binder : 'T -> Async<'U>

A function that takes the result of the computation and returns a new asynchronous computation.

computation : Async<'T>

The input computation.

Returns: Async<'U>

An asynchronous computation that performs a monadic bind on the result of computation.

Example

 let computation = Async.result 21 |> Async.bind (fun x -> Async.result (x * 2))
 computation |> Async.RunSynchronouslyImmediate // evaluates to 42

OperationCanceledException and derived types such as TaskCanceledException propagate unchanged.

computation : Async<'T>

The input computation.

Returns: Async<Result<'T, exn>>

An asynchronous computation that yields a Result: Ok with the outcome on success, or Error with the exception on failure. Propagates the underlying cancellation exception when cancellation occurs.

Example

 let safeDiv x y =
     async { return x / y } |> Async.catch
 safeDiv 10 2 |> Async.RunSynchronouslyImmediate // evaluates to Ok 5
 safeDiv 10 0 |> Async.RunSynchronouslyImmediate // evaluates to Error (DivideByZeroException ...)

OperationCanceledException and derived types such as TaskCanceledException propagate unchanged, and therefore are never passed to handler.

handler : exn -> 'T

A function to handle (non-cancellation) exceptions, yielding a recovery value based on the exception. Any exception thrown by handler will propagate.

computation : Async<'T>

The input computation.

Returns: Async<'T>

An asynchronous computation that yields the result of computation on success, or handler exn on failure. Propagates the underlying cancellation exception where cancellation occurs.

Example

 let safeDiv x y =
     async { return x / y }
     |> Async.catchWith (fun _ -> 0)
 safeDiv 10 0 |> Async.RunSynchronouslyImmediate // evaluates to 0

Returns: Async<unit>

Example

 Async.empty |> Async.RunSynchronouslyImmediate // evaluates to ()

computation : Async<'T>

The input computation.

Returns: Async<unit>

A computation that is equivalent to the input computation, but disregards the result.

Example

 let readFile filename numBytes: Async<unit> =
     async {
         use file = System.IO.File.OpenRead(filename)
         do! file.AsyncRead(numBytes) |> Async.ignore<byte[]>
     }

Example

 let computation : Async<unit> = Async.result 42 |> Async.ignore<int>
 computation |> Async.RunSynchronously // evaluates to ()

mapping : 'T -> 'U

The function to apply to the result.

computation : Async<'T>

The input computation.

Returns: Async<'U>

An asynchronous computation that applies mapping to the result of computation.

Example

 let computation = Async.result 21 |> Async.map (fun x -> x * 2)
 computation |> Async.RunSynchronouslyImmediate // evaluates to 42

The relative start and completion order of computations is arbitrary.

maxDegreeOfParallelism : int

The maximum number of computations to run concurrently. Must be > 0.

computations : Async<unit> seq

A sequence of unit computations to be parallelized.

Returns: Async<unit>

A computation that runs all inputs with limited parallelism and returns unit.

Example

 seq { for i in 1..10 -> async { printfn "%d" i } } // NOTE output order can vary
 |> Async.parallelDoLimit 3
 |> Async.RunSynchronouslyImmediate

While the result order matches the input order, the relative start and completion order of computations is arbitrary.

maxDegreeOfParallelism : int

The maximum number of computations to run concurrently. Must be > 0.

computations : Async<'T> seq

A sequence of computations to be parallelized.

Returns: Async<'T[]>

A computation that returns an array of results from the input computations in the same order they were supplied.

Example

 let results =
     seq { for i in 1..10 -> async { return i * i } }
     |> Async.parallelLimit 3
     |> Async.RunSynchronouslyImmediate
 results // evaluates to [| 1; 4; 9; 16; 25; 36; 49; 64; 81; 100 |]

value : 'T

The value to return.

Returns: Async<'T>

An asynchronous computation that returns value when executed.

Example

 let computation = Async.result 42
 computation |> Async.RunSynchronouslyImmediate // evaluates to 42

computations : Async<unit> seq

A sequence of unit computations to be executed in sequence.

Returns: Async<unit>

A computation that runs all inputs in sequence and returns unit.

Example

 // NOTE numbers are guaranteed to be printed in order 1..10
 seq { for i in 1..10 -> async { printfn "%d" i } }
 |> Async.sequentialDo
 |> Async.RunSynchronouslyImmediate