FlowStream integration

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

Converts to ordinary FlowStream, discarding successful process completion.

Creates a stream from a synchronous sequence of values. The sequence of values to be emitted by the stream. A that yields each value from the sequence. FlowStream.fromSeq [1..10] |> FlowStream.runCollect |> Flow.run ()

Runs several streams concurrently and emits their values as they arrive. Each stream keeps its own order; values from different streams interleave in arrival order. The merged stream ends when every stream has ended. The first failure is delivered after the values already buffered, and the other streams are interrupted. When the consumer stops early, every stream is interrupted. [ readerA; readerB; readerC ] |> FlowStream.mergePar |> FlowStream.runIntoQueue controlInputs

Collects all emitted values into a list. stream |> FlowStream.runCollect

Runs with live services and returns the value; raises ProcessRunException on failure.

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.

Sorts the given list using . This is a stable sort, i.e. the original order of equal elements is preserved. This is an O(n log n) operation, where n is the length of the list. The input list. The sorted list. let input = [8; 4; 3; 1; 6; 1] List.sort input Evaluates to [1; 1; 3; 4; 6; 8].

The universal flow { } computation expression.

Creates queues and offers values to them. Take values, inspect, and shut a queue down with the Dequeue functions.

Creates a queue that never rejects or suspends an offer. Memory grows with the backlog; prefer a bounded queue unless producers are otherwise limited.

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

Converts to ordinary FlowStream, discarding successful process completion.

Runs a stream and offers every value to a queue, waiting while a bounded queue is full. The queue is not shut down when the stream ends, so several streams can feed one queue; shut it down with Dequeue.shutdown once every producer has finished. If the queue is shut down first, the flow is interrupted. deviceReadings |> FlowStream.runIntoQueue controlInputs

Takes values from a , inspects it, and shuts it down. Every function here also accepts a .

Removes every available value in FIFO order, without suspending.

Runs with live services and returns the value; raises ProcessRunException on failure.

Creates hubs, publishes to them, and subscribes to them. A publish reaches every subscription that exists when it starts; a subscriber sees only values published after its subscribe completes, so a late joiner that needs current state must get it elsewhere, for example from a SubscriptionRef. Publishes are serialized, so every subscriber observes values in the same order even with concurrent publishers. Dropping, Sliding, and Unbounded subscriptions never delay the publisher. A BackPressure subscription with a full buffer suspends publish until it has room or its subscription ends. While the publisher waits, no later value reaches any subscriber, lossy ones included: keeping one order for every subscriber means a stalled lossless subscriber stalls the feed. Size a lossless subscriber's buffer for the bursts you expect, watch Dequeue.size to raise an alarm before it fills, and use Hub.tryPublish where the publisher must never wait. Shutting a hub down shuts every subscription down with Dequeue.shutdown semantics: subscribers drain their backlog, streams over subscriptions end normally, and later publishes are interrupted.

Creates a hub with no subscriptions.

Subscribes to the hub with a buffering strategy. The subscription ends when the current scope closes. Run subscribe inside Flow.scoped, a forked fiber, or an application root: a forked fiber's subscription ends with the fiber. Ending the subscription, by closing its scope or with Dequeue.shutdown, removes it from the hub and releases a publisher waiting on it. To subscribe for the life of a stream, use FlowStream.fromHub. flow { let! (readings: Hub<float>) = Hub.make () let! latest = readings |> Hub.subscribe (QueueStrategy.Sliding 1) do! readings |> Hub.publishAll [ 20.0; 21.5 ] |> Flow.ignore return! Dequeue.takeAll latest } |> Flow.scoped

What a queue, or a hub subscription, does with a value offered while it is full. Lossless delivery needs either back-pressure or unbounded memory. BackPressure keeps every value by making the producer wait; Unbounded keeps every value by growing without limit; Dropping and Sliding never make the producer wait and lose values instead. A non-positive capacity fails the flow that uses the strategy with a defect.

Lossless and never suspends the producer; memory grows with the backlog.

Runs a stream and publishes every value to a hub. Each value is published with Hub.publish, so a full BackPressure subscription slows the stream down. If the hub is shut down first, the flow is interrupted. sensor |> FlowStream.runIntoHub readings

Runs a flow in a child scope and closes that scope before returning. Resources and fibers acquired inside the flow are released after success, typed failure, defect, or interruption without waiting for the surrounding application scope to close.

The universal flow { } computation expression.

Creates queues and offers values to them. Take values, inspect, and shut a queue down with the Dequeue functions.

Creates a queue that never rejects or suspends an offer. Memory grows with the backlog; prefer a bounded queue unless producers are otherwise limited.

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 each callback in the application environment; preserves consumer errors separately.

Adds a value according to the queue's strategy. true when the value was accepted, or false when a dropping queue discarded it. A bounded queue suspends until space exists. The flow is interrupted if the queue is or becomes shut down first. flow { let! (jobs: Queue<string>) = Queue.bounded 8 return! jobs |> Queue.offer "job" }

Maps the successful value of a synchronous flow to unit. The source flow. A flow that succeeds with unit instead of the original value. let flow = Flow.succeed 42 |> Flow.ignore

Represents an error channel that cannot occur.

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

Takes values from a , inspects it, and shuts it down. Every function here also accepts a .

Removes every available value in FIFO order, without suspending.

Runs with live services and returns the value; raises ProcessRunException on failure.

Throw a exception. The exception message. Never returns. let failingFunction() = failwith "Oh no" // Throws an exception true // Never reaches this failingFunction() // Throws a System.Exception

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 values while preserving process completion.

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Int32.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted int int 'A' // evaluates to 65 int 0xff // evaluates to 255 int -10 // evaluates to -10

Selects values without losing process completion or skipping drainage of other channels.

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

Folds selected values and returns the state together with completion; capture policy is independent.

Overloaded addition operator The first parameter. The second parameter. The result of the operation. 2 + 2 // Evaluates to 4 "Hello " + "World" // Evaluates to "Hello World"

Runs with live services and returns the value; raises ProcessRunException on failure.

Folds with application workflows; typed consumer failures use ConsumerFailed.

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

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

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

Synchronous callback; use runForEachFlow for explicit service operations.

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.

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

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.

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 each callback in the application environment; preserves consumer errors separately.

Same as error. The error value to wrap in a failing flow. A flow that always fails with the provided error. let result = Flow.fail "error" |> Flow.run () // result = Failure (Cause.Fail "error")

Runs with live services and returns Exit, including typed failures and interruptions.

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.

Represents the cause of a failed workflow. The type of the domain-specific failure value.

An expected domain-specific failure.

Print to a string buffer and raise an exception with the given result. Helper printers must return strings. The formatter. The formatted result. See Printf.failwithf (link: ) for examples.

Stops before the first nonmatching value, awaits owned cleanup, and reports StoppedEarly.

Structural inequality The first parameter. The second parameter. The result of the comparison. 5 <> 5 // Evaluates to false 5 <> 6 // Evaluates to true [1; 2] <> [1; 2] // Evaluates to false

Collects every selected value plus completion. The collected list can grow without bound.

Runs with live services and returns the value; raises ProcessRunException on failure.

Builds a POSIX shell program with interpolation values passed as positional arguments.

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

Collects every selected value plus completion. The collected list can grow without bound.

Runs with live services and returns the value; raises ProcessRunException on failure.

Throw a exception. The exception message. Never returns. let failingFunction() = failwith "Oh no" // Throws an exception true // Never reaches this failingFunction() // Throws a System.Exception

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.

Tests if all elements of the collection satisfy the given predicate. The predicate is applied to the elements of the input list. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned. This is an O(n) operation in the worst case, where n is the length of the list. The function to test the input elements. The input list. True if all of the elements satisfy the predicate. let isEven a = a % 2 = 0 [2; 42] |> List.forall isEven // evaluates to true [1; 2] |> List.forall isEven // evaluates to false

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

Identifies one standard output channel.

Returns a new collection containing only the elements of the collection for which the given predicate returns "true" The function to test the input elements. The input list. A list containing only the elements that satisfy the predicate. let input = [1, "Luke"; 2, "Kirk"; 3, "Kenobi"; 4, "Spock"] let isEven x = 0 = x % 2 let isComingFromStarTrek (x,_) = isEven x input |> List.filter isComingFromStarTrek Evaluates to [(2, "Kirk"); (4, "Spock")] This is an O(n) operation, where n is the length of the list.

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.

Functional programming operators for string processing. Further string operations are available via the member functions on strings and other functionality in System.String and System.Text.RegularExpressions types. Strings and Text

Returns a new string made by concatenating the given strings with separator sep, that is a1 + sep + ... + sep + aN. The separator string to be inserted between the strings of the input sequence. The sequence of strings to be concatenated. A new string consisting of the concatenated strings separated by the separation string. Thrown when strings is null. let input1 = ["Stefan"; "says:"; "Hello"; "there!"] input1 |> String.concat " " // evaluates "Stefan says: Hello there!" let input2 = [0..9] |> List.map string input2 |> String.concat "" // evaluates "0123456789" input2 |> String.concat ", " // evaluates "0, 1, 2, 3, 4, 5, 6, 7, 8, 9" let input3 = ["No comma"] input3 |> String.concat "," // evaluates "No comma"

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

Consumes selected output without accumulating values and returns completion.

Runs with live services and returns Exit, including typed failures and interruptions.

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.

Represents the cause of a failed workflow. The type of the domain-specific failure value.

An expected domain-specific failure.

Expected process errors. Runtime cancellation remains Cause.Interrupt.

Print to a string buffer and raise an exception with the given result. Helper printers must return strings. The formatter. The formatted result. See Printf.failwithf (link: ) for examples.

Converts to ordinary FlowStream, discarding successful process completion.

Transforms the successful values of a stream using the provided function. The function to transform each value. The stream whose values should be transformed. A new stream that yields transformed values. let stream = FlowStream.fromSeq [1; 2; 3] |> FlowStream.map (fun n -> n * 2)

Returns a copy of this object converted to uppercase using the casing rules of the invariant culture. The uppercase equivalent of the current string.

Collects all emitted values into a list. stream |> FlowStream.runCollect

Runs with live services and returns the value; raises ProcessRunException on failure.