Fibers

The universal flow { } computation expression.

Starts a flow in a new fiber without waiting for it to complete. Forking turns a cold flow description into hot child work and returns a handle that can later be joined or interrupted. Prefer zipPar or race when the caller only needs a simple parallel composition. Wait for the handle with Fiber.join or Fiber.await, and stop it with Fiber.interrupt. The flow to fork. A flow that produces a handle.

Operations on a running , the handle returned by Flow.fork. Every operation returns a flow; nothing waits or interrupts until that flow runs. Reading a fiber's outcome through join, await, or interrupt marks it observed, so a defect it died with is not also reported as unobserved.

Waits for a fiber and returns its value, failing the same way the fiber failed. Joining preserves the child's error channel: a Cause.Fail becomes the same typed error, and interruption and defects remain interruption and defects. Use await to inspect the outcome instead. The fiber to join. A flow that completes with the fiber's value. let loadProfile : Flow<unit, string, string> = Flow.ok "profile" let loadOrders : Flow<unit, string, int list> = Flow.ok [ 1; 2 ] let page = flow { let! fiber = Flow.fork loadProfile let! orders = loadOrders let! profile = Fiber.join fiber return profile, orders }

Creates a successful synchronous flow. The value to wrap in a successful flow. A flow that always succeeds with the provided value.

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.

An abbreviation for the CLI type . Basic Types

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Suspends the flow for the specified duration, observing cancellation. The duration to sleep. A flow that completes after the specified delay, or is interrupted if cancelled first.

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

Gets the number of characters in the current object. The number of characters in the current string.

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

Maps values to flows and runs them with bounded concurrency, returning results in input order. At most mappings run at once; as each finishes, its worker starts the next value. The first failure interrupts the mappings still running and waits for their cleanup before the flow fails, so no sibling is left running in the background. Size CPU-bound work with Parallelism.ofProcessors. When each worker needs its own connection or handle, use traverseParUsing. The maximum number of mappings running at once. Maps each value to a flow. The values to map. A flow containing the mapped values in the order of . let! pages = urls |> Flow.traversePar (Parallelism.bounded 8) fetchPage

Creates bounds for parallel Flow and stream operators.

Creates a positive concurrency bound. Thrown when is not positive.

Initializes a new instance of the class that is empty and has the default initial capacity.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

Defers flow construction until execution time. A function that returns the flow to execute. A flow that lazily evaluates the factory when executed. let flow = Flow.delay (fun () -> Flow.succeed 42)

Execute the function as a mutual-exclusion region using the input value as a lock. The object to be locked. The action to perform during the lock. The resulting value. open System.Linq /// A counter object, supporting unlocked and locked increment type TestCounter () = let mutable count = 0 /// Increment the counter, unlocked member this.IncrementWithoutLock() = count <- count + 1 /// Increment the counter, locked member this.IncrementWithLock() = lock this (fun () -> count <- count + 1) /// Get the count member this.Count = count let counter = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter.IncrementWithoutLock()) // Evaluates to a number between 1-100000, non-deterministically because there is no locking counter.Count let counter2 = TestCounter() // Create a parallel sequence to that uses all our CPUs (seq {1..100000}).AsParallel() .ForAll(fun _ -> counter2.IncrementWithLock()) // Evaluates to 100000 deterministically because the increment to the counter object is locked counter2.Count

Adds an object to the end of the . The object to be added to the end of the . The value can be for reference types.

Creates a successful synchronous flow. The value to wrap in a successful flow. A flow that always succeeds with the provided value.

Runs a flow for each value with bounded concurrency, discarding the results. Runs like traversePar: at most at once, and the first failure interrupts the rest. The maximum number of flows running at once. The flow to run for each value. The values to process. do! files |> Flow.forEachPar (Parallelism.ofProcessors id) indexFile

Sizes a concurrency bound from the number of processors available to the process. Use this for CPU-bound work. The result is clamped to at least 1, so fun n -> n / 2 is safe on a single-core machine. The processor count is read once, when this is called. On JavaScript the count is 1. Computes the bound from the processor count. files |> Flow.traversePar (Parallelism.ofProcessors id) hashFile

The identity function The input value. The same value. id 12 // Evaluates to 12 id "abc" // Evaluates to "abc"

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.

Contains operations for working with values of type .

Yields a sequence ordered by keys. This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved. This is an O(n log n) operation, where n is the length of the sequence. The input sequence. The result sequence. Thrown when the input sequence is null. let input = seq { 8; 4; 3; 1; 6; 1 } Seq.sort input Evaluates to a sequence yielding the same results as seq { 1; 1 3; 4; 6; 8 }.

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new list from the given enumerable object. The input sequence. The list of elements from the sequence. let inputs = seq { 1; 2; 5 } inputs |> List.ofSeq Evaluates to [ 1; 2; 5 ]. This is an O(n) operation, where n is the length of the sequence.

Create a mutable reference cell The value to contain in the cell. The created reference cell. let count = ref 0 // Creates a reference cell object with a mutable Value property count.Value // Evaluates to 0 count.Value <- 1 // Updates the value count.Value // Evaluates to 1

Describes acquisition of a value together with registration of its release in the current Flow scope. The environment required to acquire the value. The typed acquisition failure. The acquired value.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Describes acquisition together with a task-based release registered in the current Flow scope.

Defers flow construction until execution time. A function that returns the flow to execute. A flow that lazily evaluates the factory when executed. let flow = Flow.delay (fun () -> Flow.succeed 42)

Creates a successful synchronous flow. The value to wrap in a successful flow. A flow that always succeeds with the provided value.

Provides atomic operations for variables that are shared by multiple threads.

Increments a specified variable and stores the result, as an atomic operation. The variable whose value is to be incremented. The incremented value. The address of is a null pointer.

Address-of. Uses of this value may result in the generation of unverifiable code. The input object. The managed pointer.

The current value of the reference cell

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Ignore the passed value. This is often used to throw away results of a computation. The value to ignore. ignore 55555 // Evaluates to ()

Represents an asynchronous operation.

Gets a task that has already completed successfully. The successfully completed task.

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

An abbreviation for the CLI type . Basic Types

Overloaded modulo operator The first parameter. The second parameter. The result of the operation. 29 % 5 // Evaluates to 4

Structural equality The first parameter. The second parameter. The result of the comparison. 5 = 5 // Evaluates to true 5 = 6 // Evaluates to false [1; 2] = [1; 2] // Evaluates to true (1, 5) = (1, 6) // Evaluates to false

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

Like traversePar, giving each worker its own resource, acquired once and reused for every value it maps. Each worker acquires when it starts and releases it when it has no values left, or when the traversal fails or is interrupted. At most resources exist at once. Use it for work that needs an expensive handle per thread of work, such as a database connection or a repository reader that is not safe to share. The maximum number of workers, and so of resources. The resource each worker acquires. Maps a value to a flow, given the worker's resource. The values to map. A flow containing the mapped values in the order of . let! matches = commits |> Flow.traverseParUsing (Parallelism.ofProcessors id) openReader (fun reader commit -> search reader commit)

Creates bounds for parallel Flow and stream operators.

Creates a positive concurrency bound. Thrown when is not positive.

The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences The start value of the range. The end value of the range. The sequence spanning the range. [1..4] // Evaluates to [1; 2; 3; 4] [1.5..4.4] // Evaluates to [1.5; 2.5; 3.5] ['a'..'d'] // Evaluates to ['a'; 'b'; 'c'; 'd'] [|1..4|] // Evaluates to an array [|1; 2; 3; 4|] { 1..4 } // Evaluates to a sequence [1; 2; 3; 4])

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.

The current value of the reference cell

Structural less-than-or-equal comparison The first parameter. The second parameter. The result of the comparison. 5 <= 1 // Evaluates to false 5 <= 5 // Evaluates to true [1; 5] <= [1; 6] // Evaluates to true

An abbreviation for the CLI type . Basic Types

Represents a cold workflow that reads an environment, returns a typed result, and is executed explicitly through one of its execution members such as ToTask, ToAsync, or RunSynchronously. The type of the environment dependency. The type of the failure value. The type of the success value.

An environment containing only a clock, for timed flows with no other services.

Suspends the flow for the specified duration, observing cancellation. The duration to sleep. A flow that completes after the specified delay, or is interrupted if cancelled first.

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

An abbreviation for the CLI type . Basic Types

The universal flow { } computation expression.

Creates and clears and values.

Creates an empty slot for Flow.forkReplacing.

Transforms a sequence of values into a flow and stops at the first failure. A function that maps each value to a flow. The sequence of values to transform. A flow containing a list of the successful mapped values. let flows = [1; 2; 3] |> Flow.traverse (fun x -> Flow.succeed (x * 2))

Starts a flow in a new fiber held by , interrupting the fiber it replaces. Latest wins: the previous fiber in the slot is signalled to stop and is not waited for, so the new request starts at once. Its outcome is marked observed. Use this for UI requests where a result for stale input is worthless, such as search-as-you-type. The slot that holds the current fiber. The flow to run. A flow that produces the new fiber's handle. let onQueryChanged slot query = search query |> Flow.forkReplacing slot |> Flow.ignore

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Returns the last element of the list. The input list. The last element of the list. Thrown when the input does not have any elements. [ "pear"; "banana" ] |> List.last Evaluates to banana [ ] |> List.last Throws ArgumentException Lists are represented as linked lists so this is an O(n) operation, where n is the length of the list.

Operations on a running , the handle returned by Flow.fork. Every operation returns a flow; nothing waits or interrupts until that flow runs. Reading a fiber's outcome through join, await, or interrupt marks it observed, so a defect it died with is not also reported as unobserved.

Waits for a fiber and returns its value, failing the same way the fiber failed. Joining preserves the child's error channel: a Cause.Fail becomes the same typed error, and interruption and defects remain interruption and defects. Use await to inspect the outcome instead. The fiber to join. A flow that completes with the fiber's value. let loadProfile : Flow<unit, string, string> = Flow.ok "profile" let loadOrders : Flow<unit, string, int list> = Flow.ok [ 1; 2 ] let page = flow { let! fiber = Flow.fork loadProfile let! orders = loadOrders let! profile = Fiber.join fiber return profile, orders }

Returns the first N elements of the list. Throws InvalidOperationException if the count exceeds the number of elements in the list. List.truncate returns as many items as the list contains instead of throwing an exception. This is an O(count) operation. The number of items to take. The input list. The result list. Thrown when the input list is empty. Thrown when count exceeds the number of elements in the list. let inputs = ["a"; "b"; "c"; "d"] inputs |> List.take 2 Evaluates to ["a"; "b"] let inputs = ["a"; "b"; "c"; "d"] inputs |> List.take 6 Throws InvalidOperationException. let inputs = ["a"; "b"; "c"; "d"] inputs |> List.take 0 Evaluates to the empty list.

Gets the number of items contained in the list

Overloaded subtraction operator The first parameter. The second parameter. The result of the operation. 10 - 2 // Evaluates to 8

Waits for a fiber and returns its , never failing. Use this when the caller decides what the fiber's outcome means, for example a cache that shares one computation between callers, or a supervisor that restarts children. Unlike Deferred.await, which returns the completed value, this returns the whole exit. Interrupting the awaiting flow stops the wait, not the fiber. The fiber to wait for. A flow that succeeds with the fiber's exit. flow { match! Fiber.await fiber with | Exit.Success value -> return Some value | Exit.Failure _ -> return None }

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow failed due to a specific cause.

Returns whether the cause tree contains an interruption signal.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.