Core Model on FsFlow

Execution Semantics

Mon, 01 Jan 0001 00:00:00 +0000

Execution Semantics

This page shows the exact execution rules for Flow, including how a cold program becomes an Effect and resolves to an Exit.

FsFlow uses a unified Flow<'env, 'error, 'value> model that handles synchronous code, F# Async, and .NET Task interop natively.

Execution Shape

Conceptually, execution is:

Flow -> Effect -> Exit

More precisely:

Flow is the cold program you define.
Effect is the deferred runnable carrier.
Exit is the terminal outcome after execution.

Success and Typed Failure

Every Flow execution results in an Exit<'value, 'error>:

Task and Async Interop

Mon, 01 Jan 0001 00:00:00 +0000

Task and Async Interop

FsFlow provides a single, unified computation expression—flow {}—that handles synchronous code, F# Async, and .NET Task interop natively. You don’t have to choose between different builders; the same flow can orchestrate all these effect types.

Direct Binds

Inside a flow {} block, you can use let! to bind many common F# and .NET types directly. FsFlow handles the conversion to its internal execution model automatically.

Type	Outcome
`Flow<'env, 'error, 'value>`	Continues with the flow’s value.
`Result<'value, 'error>`	Continues on `Ok`, short-circuits on `Error`.
`Async<'value>`	Awaits the async and continues with the value.
`Async<Result<'value, 'error>>`	Awaits the async and handles the Result outcome.
`Task<'value>`	Awaits the task and continues with the value.
`Task<Result<'value, 'error>>`	Awaits the task and handles the Result outcome.
`ValueTask<'value>`	Awaits the value task and continues with the value.
`ValueTask<Result<'value, 'error>>`	Awaits and handles the Result outcome.

Example: Mixed Orchestration

let fetchUser (id: int) : Task<User> = ...
let validate (user: User) : Result<User, string> = ...
let saveUser (user: User) : Async<unit> = ...

let processUser id =
    flow {
        // Bind a .NET Task
        let! user = fetchUser id
        
        // Bind a Result
        let! validUser = validate user
        
        // Bind an F# Async
        do! saveUser validUser
        
        return "Done"
    }

Option and ValueOption

Option<'value> and ValueOption<'value> can also be bound directly, but only if the flow’s error type is unit.

Architectural Styles

Mon, 01 Jan 0001 00:00:00 +0000

Architectural Styles

This page shows how the FsFlow workflow family should fit into your application architecture without forcing one app shape on every codebase.

FsFlow supports three valid architectural styles.

Three related workflow families. Three valid architectural styles. Choose based on app shape and team preferences.

1. Booted App Environment

Use this when your application already has a conventional booted runtime and passing one explicit application environment keeps composition simple.