Skip to main content
net9.0

Structured concurrency primitives for Effect. Fibers, Ref, Deferred, Queue, parallel/race combinators, timeouts, and supervision.

Published
Apr 6, 2026
7mo ago
Total Downloads
209
209

Install

dotnet add package Effect.Concurrency --version 0.1.0-alpha.2
ProductVersions
.NET
net9.0

README

Effect.Concurrency

Structured concurrency primitives for Effect.

Fibers, concurrent data structures, streams, and combinators for parallel and racing effects.

Install

dotnet add package Effect.Concurrency --prerelease

Requires the Effect package.

Fibers

open Eff

let program =
    effect {
        let! fiber = EffectConcurrency.fork () longRunningEffect
        // do other work...
        let! result = Fiber.join fiber
        return result
    }

// Interrupt a fiber
do! Fiber.interrupt fiber

// Race multiple effects
let! fastest = EffectConcurrency.raceAll [ server1; server2 ]

// Timeout
let! result = myEffect |> EffectConcurrency.timeout (TimeSpan.FromSeconds 5.0)
// Ok (Some value) or Ok None

Ref — thread-safe mutable state

let program =
    effect {
        let! counter = Ref.make 0
        let inc = effect { for _ in 1..1000 do do! Ref.update ((+) 1) counter }
        let! _ = EffectConcurrency.zipPar inc inc
        return! Ref.get counter  // Ok 2000
    }

Deferred — one-shot promise

let program =
    effect {
        let! promise = Deferred.make<unit, AppError, string> ()
        let! fiber = EffectConcurrency.fork () (effect {
            do! Effect.sleep 100
            let! _ = Deferred.succeed "done" promise
            return ()
        })
        let! value = Deferred.await promise
        return value
    }

Queue — bounded async channel

Backed by System.Threading.Channels.Channel<T>.

let program =
    effect {
        let! q = Queue.bounded<unit, AppError, int> 5
        let producer = effect { for i in 1..10 do do! Queue.put i q }
        let consumer = effect { for _ in 1..10 do let! _ = Queue.take q in () }
        let! _ = EffectConcurrency.zipPar producer consumer
        return ()
    }

Stream — lazy async sequences

Push-based streams with backpressure, typed errors, and cancellation.

let result =
    Stream.range 1 100
    |> Stream.filter (fun x -> x % 2 = 0)
    |> Stream.map (fun x -> x * x)
    |> Stream.take 10
    |> Stream.runCollect
    |> Effect.run ()

// Merge concurrent streams
let merged = Stream.merge stream1 stream2

// Pipe to/from queues
do! myStream |> Stream.toQueue queue
let fromQ = Stream.fromQueue queue |> Stream.take 100

TestClock — deterministic time

Test time-dependent effects without real delays.

let clock = TestClock()

let program = effect {
    do! clock.Sleep 5000
    return "done"
}

let resultTask = Effect.run () program
clock.AdvanceByMillis 5000  // resolves instantly

Changes from Previous Version

No structural changes between v0.1.0-alpha.1 and v0.1.0-alpha.2.

Adoption Assessment

Assess this package against its supported frameworks, license, maintenance signals and dependency graph before making it a project standard.

This version is marked prerelease. Validate its API and upgrade path before production use.Compatibility metadata lists 1 target framework; confirm the exact target used by your application.

Related Guides & Workflows

Learn how to evaluate, integrate, or audit this package in your .NET project.