Trace workflows and inspect them in Aspire

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Provides APIs to create and start objects and to register objects to listen to the events.

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

Structural greater-than The first parameter. The second parameter. The result of the comparison. 5 > 1 // Evaluates to true 5 > 5 // Evaluates to false (1, "a") > (1, "z") // Evaluates to false

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

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

An abbreviation for the CLI type . Basic Types

Immutable maps based on binary trees, where keys are ordered by F# generic comparison. By default comparison is the F# structural comparison function or uses implementations of the IComparable interface on key values. See the module for further operations on maps. All members of this class are thread-safe and may be used concurrently from multiple threads.

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.

Bridges a synchronous callback into a bounded, scope-owned stream. When full, the newest value is dropped; Value returns false. The subscription is disposed on completion, failure, interruption, or early termination. Subscribe should register cleanup with Flow.scopeFinalizer for anything it attaches before a later step can fail or be interrupted. Callbacks after completion are ignored.

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)

Allows listening to the start and stop activity events and gives the opportunity to decide creating an activity for sampling scenarios.

Gets or sets the callback that allows deciding if activity object events that were created using the activity source object should be listened or not. to listen events; otherwise.

Returns the activity source name. A string that represents the activity source name.

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

Gets or sets the callback that is used to decide if creating objects with a specific data state is allowed. A sample activity instance.

A delegate that defines the signature of the callbacks used in the sampling process. The Activity creation options used by callbacks to decide creating the Activity object or not. The type of the requested parent to create the Activity object with. Should be either a string or an instance. An object containing the sampling results, which indicate the amount of data to collect for the related .

A representation that conforms to the W3C TraceContext specification. It contains two identifiers: a TraceId and a SpanId, along with a set of common TraceFlags and system-specific TraceState values.

Enumeration values used by to indicate the amount of data to collect for the related . Requesting more data causes a greater performance overhead.

The activity object should be populated with all the propagation information and also all other properties such as Links, Tags, and Events. Using this value causes to return .

Gets or sets the callback used to listen to the activity stop event. An activity callback instance used to listen to the activity stop event.

Gets the list of tags that represent information to log along with the activity. This information is not passed on to the children of this activity. A key-value pair enumeration of tags and objects.

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

Contains operations for working with values of type .

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the MoveNext method on enumerators retrieved from the object. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence. A function to transform items from the input sequence. The input sequence. The result sequence. Thrown when the input sequence is null. let inputs = ["a"; "bbb"; "cc"] inputs |> Seq.map (fun x -> x.Length) Evaluates to a sequence yielding the same results as seq { 1; 3; 2 }

Gets the key in the key/value pair. A that is the key of the .

Converts the argument to a string using ToString. For standard integer and floating point values and any type that implements IFormattable, ToString conversion uses CultureInfo.InvariantCulture. The input value. The converted string. string 'A' // evaluates to "A" string 0xff // evaluates to "255" string -10 // evaluates to "-10"

Gets the value in the key/value pair. A that is the value of the .

Contains operations for working with values of type .

Returns a new map made from the given bindings. The input sequence of key/value pairs. The resulting map. This is an O(n log n) operation, where n is the number of elements in the sequence. let input = seq { (1, "a"); (2, "b") } input |> Map.ofSeq // evaluates to map [(1, "a"); (2, "b")]

Offers a value; false means it was dropped or the stream has ended.

Gets or sets the display name of the activity. A string that represents the activity display name.

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

Adds a listener to the activity starting and stopping events. The activity listener object to use for listening to the activity events.

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

Ends normally.

Provides a mechanism for releasing unmanaged resources.

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

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.

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.

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

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

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

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 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.

Return the first element of a tuple, fst (a,b) = a. The input tuple. The first value. fst ("first", 2) // Evaluates to "first"

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

Wraps a flow in an application-owned activity source, rendering typed errors without reflection. Errors are rendered with their own ToString, or by type name when that ToString needs reflection NativeAOT removed. Use traceWith to supply a renderer. The application-owned activity source that emits the span. The name of the activity. The flow to trace. A flow that executes within the activity span.

Creates values.

Captures an application-owned activity source. The application-owned activity source that emits application spans.

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

Wraps a flow in a span from this tracer's activity source, rendering typed errors with string. The name of the activity.

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

Wraps a flow in the ambient application tracer installed by withTracer, and renders typed errors with string. Throws if no ambient tracer is installed. Use traceOn to supply a source explicitly instead of relying on the ambient one.

Installs an application-owned as the ambient tracer for the scope of . trace and traceWith read this ambient tracer; child fibers forked within the scope inherit it. The application-owned tracer to install. The flow to run with the tracer installed.

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

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 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.

Return the first element of a tuple, fst (a,b) = a. The input tuple. The first value. fst ("first", 2) // Evaluates to "first"

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

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Scopes the OpenTelemetry enduser.id span attribute around a workflow.

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

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

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 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.

Contains operations for working with values of type .

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. The input key. The input map. The found Some value or None. Maps are represented as binary trees so this is an O(log n) operation, where n is the number of bindings in the map. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.tryFind 1 // evaluates to Some "a" sample |> Map.tryFind 3 // evaluates to None

The representation of "Value of type 'T" The input value. An option representing the value.

Creates typed keys for application-defined telemetry attributes.

Creates a string-valued attribute key.

Creates a 64-bit integer-valued attribute key.

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

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Scopes telemetry attributes around a workflow.

Creates an application-defined attribute by pairing a typed key with a value.

Wraps a flow in a new activity from the supplied application-owned source, exports the ambient telemetry context, and stamps the final exit onto the span. The activity stops when the workflow settles, so span duration covers asynchronous work. On settle the span receives ActivityStatusCode from the exit, axial.flow.outcome (success/fail/die/interrupt), axial.flow.error for typed errors, OpenTelemetry exception.* tags for defects, axial.flow.interrupted for cancellation, and axial.flow.cause with the pretty-printed tree for composite causes. Register the source name with the host's OpenTelemetry tracing pipeline. Axial's automatic fiber spans continue to use the Axial source because they describe Axial runtime behavior. The application-owned activity source that emits the span. Renders typed errors for the axial.flow.error attribute. The name of the activity. The flow to trace. A flow that executes within the activity span.

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

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 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.

Contains operations for working with values of type .

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. The input key. The input map. The found Some value or None. Maps are represented as binary trees so this is an O(log n) operation, where n is the number of bindings in the map. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.tryFind 1 // evaluates to Some "a" sample |> Map.tryFind 3 // evaluates to None

The representation of "Value of type 'T" The input value. An option representing the value.

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

An empty telemetry context.

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

Adds the OpenTelemetry enduser.id span attribute to a context.

Adds or replaces one attribute.

Creates an application-defined attribute by pairing a typed key with a value.

Scopes a telemetry context around a workflow.

An immutable set of telemetry attributes propagated with a running workflow.

Builds and scopes ambient telemetry attributes for Axial workflows. Context is immutable and lexically scoped. Nested attributes override matching outer keys only for the wrapped workflow, and child fibers inherit the context present when they are forked.

Reads a typed attribute from a context.

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

An abbreviation for the CLI type . Basic Types

The type of optional values. When used from other CLI languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of null as a value representation. Options

The universal flow { } computation expression.

Reads the currently scoped telemetry context.

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

Scopes a telemetry context around a workflow.

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

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 representation of "Value of type 'T" The input value. An option representing the value.

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

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

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

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the span-per-fiber telemetry observer: every forked fiber becomes an axial.flow.fiber span covering fork to settle. See observerWithSpans. The source flow. A flow whose forked fibers each produce a span on the installed tracer.

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

OpenTelemetry-compatible fiber runtime metrics on the Axial meter. Register the meter with your OpenTelemetry pipeline (AddMeter("Axial")) and every metric appears in any OTLP backend, including the Aspire dashboard's metrics view. Instruments: axial.flow.fibers.started and axial.flow.fibers.settled (counters; settled is tagged with axial.flow.fiber.status), axial.flow.fibers.live (up-down counter), axial.flow.fiber.duration (histogram, seconds, tagged with status), and axial.flow.fibers.unobserved_defects (counter).

Installs the metrics fiber observer on a flow, composing with any observer already installed, typically once at the application edge, stacked with FiberTelemetry.observe or a FiberRegistry. The source flow. A flow whose forked fibers report runtime metrics on the Axial meter.

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

Broadcasts every published value to every current subscription. Create one with Hub.make. Use a hub when there can be zero or many consumers. The type of the published values.

An abbreviation for the CLI type . Basic Types

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

Represents an error channel that cannot occur.

The universal flow { } computation expression.

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

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.

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. A full buffer suspends the producer until a value is taken.

OpenTelemetry-compatible queue and hub-subscription metrics on the Axial meter. Register a queue, or a hub subscription, under a name with QueueMetrics.observe. Its figures are read only when the metrics pipeline collects, so observing a queue adds no cost to offers and takes. Every measurement is tagged with axial.queue.name. Instruments: axial.queue.size, axial.queue.capacity (bounded queues only), axial.queue.waiting_takers, and axial.queue.waiting_offerers (gauges); and axial.queue.accepted, axial.queue.dropped, and axial.queue.evicted (counters). Alert on axial.queue.size approaching axial.queue.capacity for a lossless subscriber, before it fills and holds up the publisher, and on the rate of axial.queue.dropped or axial.queue.evicted for a lossy one.

Reports a queue's metrics under until the current scope closes. Works for a Queue and for a hub subscription, which is a Dequeue. Run it in the scope that owns the queue, such as the fiber that consumes a subscription, so the queue stops being reported when that scope ends. The value of the axial.queue.name tag. The queue or subscription to report. flow { let! history = readings |> Hub.subscribe (QueueStrategy.BackPressure 10_000) do! history |> QueueMetrics.observe "historian" do! history |> FlowStream.fromDequeue |> FlowStream.runForEachFlow record }

Creates a stream that takes values from a queue or hub subscription until it is shut down and drained. Shutdown is the normal end of the stream, not a failure: after Dequeue.shutdown or Hub.shutdown the stream emits the remaining backlog and then completes. Each pull suspends while the queue is empty. Interrupting a pull leaves any value it would have received in the queue. flow { let! (jobs: Queue<string>) = Queue.bounded 8 do! jobs |> Queue.offerAll [ "a"; "b" ] |> Flow.ignore do! Dequeue.shutdown jobs return! jobs |> FlowStream.fromDequeue |> FlowStream.runCollect }

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

Initializes a new instance of the class.

Initializes a new instance of the class that is empty, has the default initial capacity, and uses the default equality comparer for the key type.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

The MeterListener is class used to listen to the metrics instrument measurements recording.

Gets or sets the callback to get notified when an instrument is published. The callback to get notified when an instrument is published.

Gets the Meter name. The Meter name

Gets the Meter that created the instrument.

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

Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand The first value. The second value. The result of the operation.

Determines whether the beginning of this string instance matches the specified string. The string to compare. if matches the beginning of this string; otherwise, . is .

Gets the instrument name.

Starts listening to a specific instrument measurement recording. The instrument to listen to. A state object that will be passed back to the callback getting measurements events.

Sets a callback for a specific numeric type to get the measurement recording notification from all instruments which enabled listening and was created with the same specified numeric type. If a measurement of type T is recorded and a callback of type T is registered, that callback will be used. The callback which can be used to get measurement recording of numeric type T. The type of the numeric measurement.

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

Contains operations for working with arrays. See also F# Language Guide - Arrays.

Returns the first element for which the given function returns True. Return None if no such element exists. The function to test the input elements. The input array. The first element that satisfies the predicate, or None. Thrown when the input array is null. Try to find the first even number: let inputs = [| 1; 2; 3 |] inputs |> Array.tryFind (fun elm -> elm % 2 = 0) Evaluates to Some 2 Try to find the first even number: let inputs = [| 1; 5; 3 |] inputs |> Array.tryFind (fun elm -> elm % 2 = 0) Evaluates to None This is an O(n) operation in the worst case, where n is the length of the array.

Gets the key in the key/value pair. A that is the key of the .

Contains operations for working with options. Options

map f inp evaluates to match inp with None -> None | Some x -> Some (f x). A function to apply to the option value. The input option. An option of the input value after applying the mapping function, or None if the input is None. None |> Option.map (fun x -> x * 2) // evaluates to None Some 42 |> Option.map (fun x -> x * 2) // evaluates to Some 84

Converts the argument to a string using ToString. For standard integer and floating point values and any type that implements IFormattable, ToString conversion uses CultureInfo.InvariantCulture. The input value. The converted string. string 'A' // evaluates to "A" string 0xff // evaluates to "255" string -10 // evaluates to "-10"

Gets the value in the key/value pair. A that is the value of the .

Gets the value of the option if the option is Some, otherwise returns the specified default value. The specified default value. The input option. The option if the option is Some, else the default value. Identical to the built-in operator, except with the arguments swapped. (99, None) ||> Option.defaultValue // evaluates to 99 (99, Some 42) ||> Option.defaultValue // evaluates to 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

Gets or sets the value associated with the specified key. The key of the value to get or set. The value associated with the specified key. If the specified key is not found, a get operation throws a , and a set operation creates a new element with the specified key. is . The property is retrieved and does not exist in the collection.

Enables the listener to start listening to instruments measurement recording.

Removes all keys and values from the .

Calls all Observable instruments that the listener is listening to, and calls with every collected measurement.

Gets the value associated with the specified key. The key of the value to get. When this method returns, contains the value associated with the specified key, if the key is found; otherwise, the default value for the type of the parameter. This parameter is passed uninitialized. if the contains an element with the specified key; otherwise, . is .

The representation of "Value of type 'T" The input value. An option representing the value.

The representation of "No value"

Provides a mechanism for releasing unmanaged resources.

Disposes the listeners which will stop it from listening to any instrument.

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

Represents an error channel that cannot occur.

The type of optional values. When used from other CLI languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of null as a value representation. Options

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.

The universal flow { } computation expression.

An asynchronous FIFO queue for handing values between fibers, with an overflow strategy chosen at creation. Create one with Queue.make or a shorthand such as Queue.bounded, offer with Queue.offer, and take with the Dequeue functions. A queue is meant for one logical consumer; use Hub when zero or many consumers each need every value. The type of the queued values.

An abbreviation for the CLI type . Basic Types

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

Creates a queue whose offer evicts the oldest value when full and returns true. Shorthand for Queue.make (QueueStrategy.Sliding capacity).

OpenTelemetry-compatible queue and hub-subscription metrics on the Axial meter. Register a queue, or a hub subscription, under a name with QueueMetrics.observe. Its figures are read only when the metrics pipeline collects, so observing a queue adds no cost to offers and takes. Every measurement is tagged with axial.queue.name. Instruments: axial.queue.size, axial.queue.capacity (bounded queues only), axial.queue.waiting_takers, and axial.queue.waiting_offerers (gauges); and axial.queue.accepted, axial.queue.dropped, and axial.queue.evicted (counters). Alert on axial.queue.size approaching axial.queue.capacity for a lossless subscriber, before it fills and holds up the publisher, and on the rate of axial.queue.dropped or axial.queue.evicted for a lossy one.

Reports a queue's metrics under until the current scope closes. Works for a Queue and for a hub subscription, which is a Dequeue. Run it in the scope that owns the queue, such as the fiber that consumes a subscription, so the queue stops being reported when that scope ends. The value of the axial.queue.name tag. The queue or subscription to report. flow { let! history = readings |> Hub.subscribe (QueueStrategy.BackPressure 10_000) do! history |> QueueMetrics.observe "historian" do! history |> FlowStream.fromDequeue |> FlowStream.runForEachFlow record }

Adds values in order according to the queue's strategy. true when every value was accepted. A dropping queue accepts values while it has room and returns false if it discarded any. A bounded queue suspends as needed; values from other producers may be interleaved between the batch's values, but the batch's own order is kept. If the flow is interrupted part way, the values already accepted stay in the queue. flow { let! (samples: Queue<float>) = Queue.unbounded () do! samples |> Queue.offerAll [ 1.0; 2.0; 3.0 ] |> Flow.ignore return! samples |> Dequeue.takeUpTo 500 }

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

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

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.

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

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 representation of "Value of type 'T" The input value. An option representing the value.

The representation of "No value"

An abbreviation for the CLI type . Basic Types

The type of optional values. When used from other CLI languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of null as a value representation. Options

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.

Represents an error channel that cannot occur.

Creates a registry that remembers the last 200 settled fibers and unobserved defects.

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

Tracks every fiber forked inside the flow in . The registry's observer is composed with any observer already installed, so telemetry hooks and the registry can coexist from separate installs. Install once at the application edge, keep the registry, and call registry.DumpAt(clock) (or registry.Snapshot()) whenever a live fiber tree is needed. The registry that receives fiber lifecycle events. The source flow. A flow whose forked fibers are tracked in the registry.

OpenTelemetry-compatible fiber runtime metrics on the Axial meter. Register the meter with your OpenTelemetry pipeline (AddMeter("Axial")) and every metric appears in any OTLP backend, including the Aspire dashboard's metrics view. Instruments: axial.flow.fibers.started and axial.flow.fibers.settled (counters; settled is tagged with axial.flow.fiber.status), axial.flow.fibers.live (up-down counter), axial.flow.fiber.duration (histogram, seconds, tagged with status), and axial.flow.fibers.unobserved_defects (counter).

Installs the metrics fiber observer on a flow, composing with any observer already installed, typically once at the application edge, stacked with FiberTelemetry.observe or a FiberRegistry. The source flow. A flow whose forked fibers report runtime metrics on the Axial meter.

Fiber-lifecycle observability on the installed OpenTelemetry tracer: the JavaScript counterpart of the .NET package's FiberTelemetry, with the same span names and attribute vocabulary.

Installs the defect-only telemetry fiber observer, typically once at the application edge. The source flow. A flow whose forked fibers report defects through the installed tracer.

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

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. 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 seconds, where the specification is accurate to the nearest millisecond. A number of seconds, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Represents a handle to a workflow that has already been started. A fiber is the hot counterpart to a cold Flow, returned by Flow.fork. Wait for it with Fiber.join (its value, re-raising its failure) or Fiber.await (its Exit), check it with Fiber.poll, and stop it with Fiber.interrupt. The failure type of the running workflow. The success type of the running workflow.

Starts a flow in a new fiber carrying a diagnostic name. The name appears in FiberDump snapshots, FiberRegistry dumps, and telemetry fiber spans, so long-lived background fibers are recognizable in diagnostics instead of showing as bare ids. The diagnostic name recorded in the fiber's metadata. The flow to fork. A flow that produces a handle.

Exports structured fiber dumps into traces.

Records the registry's current live-fiber tree on the active trace: as an axial.flow.fiber.dump event on the current activity when one exists, otherwise as a standalone axial.flow.fiber.dump span. The event carries axial.flow.fibers.live and the rendered tree in axial.flow.fiber.dump.tree, so dumps land next to the traces they explain in any OTLP backend, including the Aspire dashboard. The registry to snapshot.

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.