Repository F# setup

open System
open System.IO
open System.Threading
open System.Threading.Tasks
open Axial
open Axial.Layers
open Axial.Console
open Axial.FileSystem
open Axial.Hosting
open Axial.Hosting.Browser
open Axial.Hosting.Node
open Axial.PlatformService
open Axial.State
open Axial.Telemetry
open Axial.Telemetry.JavaScript

Consuming Streams

A stream is only a description until a terminal consumer turns it into a Flow. Running that Flow opens the source and starts pulling.

Incremental consumers

Prefer incremental consumers when the stream may be large or unbounded:

Verified

> (FlowStream.fromSeq [ 1..100 ] : FlowStream<int>)
- |> FlowStream.runFold (+) 0
- |> Flow.run ();;

val it: Exit<int,Never> = Success 5050

Axial.FlowStreamModule

fromSeq: 'value seq -> FlowStream<'env,'error,'value>

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 ()

(..): ^T -> ^T -> ^T seq

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])

FlowStream

A stream with no environment requirement and no typed failure.

int

An abbreviation for the CLI type . Basic Types

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

runFold: ('state -> 'value -> 'state) -> 'state -> FlowStream<'env,'error,'value> -> Flow<'env,'error,'state>

Folds a stream into one value inside Flow. stream |> FlowStream.runFold (+) 0

(+): ^T1 -> ^T2 -> ^T3

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"

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

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

FlowStream.runForEach exposes each value without retaining the complete stream:

Verified

> let observed = ResizeArray<int>() in
- (FlowStream.fromSeq [ 1; 2; 3 ] : FlowStream<int>)
- |> FlowStream.runForEach observed.Add
- |> Flow.map (fun () -> List.ofSeq observed)
- |> Flow.run ();;

val observed: List<int> = seq [1; 2; 3]
val it: Exit<int list,Never> = Success [1; 2; 3]

observed: ResizeArray<int>

``.ctor``: unit -> unit

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

int

An abbreviation for the CLI type . Basic Types

Axial.FlowStreamModule

fromSeq: 'value seq -> FlowStream<'env,'error,'value>

FlowStream

A stream with no environment requirement and no typed failure.

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

runForEach: ('value -> unit) -> FlowStream<'env,'error,'value> -> Flow<'env,'error,unit>

Executes the stream and performs a synchronous action for each successful value. The function to execute for each value emitted by the stream. The stream to execute. A flow that represents the execution of the stream. If the stream fails, the flow fails with the same cause. FlowStream.fromSeq ["a"; "b"; "c"] |> FlowStream.runForEach (printfn "%s") |> Flow.run ()

Add: int -> unit

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.

Axial.Flow

map: ('value -> 'next) -> Flow<'env,'error,'value> -> Flow<'env,'error,'next>

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)

Microsoft.FSharp.Collections.ListModule

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.

ofSeq: 'T seq -> 'T list

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.

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

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

Use FlowStream.runForEachFlow when handling each value is effectful:

Verified

> let saved = ResizeArray<string>() in
- (FlowStream.fromSeq [ "A"; "B" ] : FlowStream<string>)
- |> FlowStream.runForEachFlow (fun letter ->
-     Flow.delay (fun () ->
-         saved.Add letter
-         Flow.succeed ()))
- |> Flow.map (fun () -> List.ofSeq saved)
- |> Flow.run ();;

val saved: List<string> = seq ["A"; "B"]
val it: Exit<string list,Never> = Success ["A"; "B"]

saved: ResizeArray<string>

``.ctor``: unit -> unit

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

string

An abbreviation for the CLI type . Basic Types

Axial.FlowStreamModule

fromSeq: 'value seq -> FlowStream<'env,'error,'value>

FlowStream

A stream with no environment requirement and no typed failure.

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

runForEachFlow: ('value -> Flow<'env,'error,unit>) -> FlowStream<'env,'error,'value> -> Flow<'env,'error,unit>

Runs an effectful action for every stream value. stream |> FlowStream.runForEachFlow save

letter: string

Axial.Flow

delay: (unit -> Flow<'env,'error,'value>) -> Flow<'env,'error,'value>

Defers flow construction until execution time. A function that returns the flow to execute. Recursive calls deferred here are consumed by the executor without growing a chain of parent tasks. Work that must run after the recursive call still needs storage until that call finishes. A flow that lazily evaluates the factory when executed. let flow = Flow.delay (fun () -> Flow.succeed 42)

Add: string -> unit

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.

succeed: 'value -> Flow<'env,'error,'value>

Same as ok. The value to wrap in a successful flow. A flow that always succeeds with the provided value. let result = Flow.succeed 42 |> Flow.run () // result = Success 42

map: ('value -> 'next) -> Flow<'env,'error,'value> -> Flow<'env,'error,'next>

Microsoft.FSharp.Collections.ListModule

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.

ofSeq: 'T seq -> 'T list

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

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

FlowStream.runDrain ignores emitted values while preserving producer effects.

Collect finite streams

FlowStream.runCollect returns all values as a list:

Verified

> (FlowStream.fromSeq [ 1; 2; 3 ] : FlowStream<int>)
- |> FlowStream.runCollect
- |> Flow.run ();;

val it: Exit<int list,Never> = Success [1; 2; 3]

Axial.FlowStreamModule

fromSeq: 'value seq -> FlowStream<'env,'error,'value>

FlowStream

A stream with no environment requirement and no typed failure.

int

An abbreviation for the CLI type . Basic Types

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

runCollect: FlowStream<'a,'b,'c> -> Flow<'a,'b,'c list>

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

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

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

Use it only when the stream is known to be finite and the complete list is required. It retains every value until completion.

The terminal consumer owns the stream scope

You do not normally wrap stream consumption in Flow.scoped. Every terminal operation (FlowStream.runFold, FlowStream.runForEach, FlowStream.runForEachFlow, FlowStream.runCollect, and FlowStream.runDrain) automatically creates a child scope when its returned Flow starts running, and closes it — running finalizers in reverse order and interrupting and awaiting unfinished child fibers — before returning its Exit. An outer Flow.scoped is only for grouping the terminal Flow with other work; it is not required for stream safety.

The full six-step lifecycle and the per-operator scope-ownership rules are in the scopes guide.

Consuming Streams

Incremental consumers

Collect finite streams

The terminal consumer owns the stream scope

Overview

Docs

API Reference