Section 17: Concurrency Extended

Goal: Complete concurrency support with Sendable trait, role-based channels, nursery pattern, and structured concurrency

PROPOSALS:

docs/ori_lang/proposals/approved/sendable-channels-proposal.md

docs/ori_lang/proposals/approved/sendable-interior-mutability-proposal.md

docs/ori_lang/proposals/approved/task-async-context-proposal.md

docs/ori_lang/proposals/approved/closure-capture-semantics-proposal.md

docs/ori_lang/proposals/approved/parallel-execution-guarantees-proposal.md

docs/ori_lang/proposals/approved/nursery-cancellation-proposal.md

docs/ori_lang/proposals/approved/timeout-spawn-patterns-proposal.md

Dependencies: Section 16 (Async Support), Section 3 (Traits — Sendable trait definition), Section 5 (Type Declarations — sum types for NurseryErrorMode, CancellationReason), Section 6 (Capabilities — uses Suspend/uses Async)

Sync Points: New Types (multi-crate sync required)

Adding the following types requires updates across all these crates:

Channel types (Producer<T>, Consumer<T>, CloneableProducer<T>, CloneableConsumer<T>):

ori_ir — Add type variants or generic type representations
ori_types — Register types, validate T: Sendable bounds, method signatures
ori_eval — Runtime value representations, method dispatch (send, receive, close, is_closed)
ori_llvm — LLVM type layouts, codegen for channel operations
library/std/prelude.ori — Type definitions and trait impls (Iterable for Consumer)

Concurrency types (Nursery, NurseryErrorMode, CancellationError, CancellationReason):

ori_ir — Sum type variants for NurseryErrorMode (CancelRemaining | CollectAll | FailFast) and CancellationReason (Timeout | SiblingFailed | NurseryExited | ExplicitCancel | ResourceExhausted)
ori_types — Register types, pattern exhaustiveness for sum types
ori_eval — Runtime value representations, nursery execution, cancellation state machine
ori_llvm — LLVM type layouts, codegen for nursery pattern and cancellation
library/std/prelude.ori — Type definitions in prelude

Built-in function (is_cancelled()):

ori_types — Type signature () -> bool in infer_ident()
ori_eval — Runtime implementation checking task cancellation state
ori_llvm — Codegen for is_cancelled intrinsic
library/std/prelude.ori — Prelude registration

17.0 Task and Async Context Definitions

Proposal: proposals/approved/task-async-context-proposal.md

Foundational definitions for tasks, async contexts, and suspension points that the rest of Section 17 depends on.

Implementation

17.1 Sendable Trait

Proposal: proposals/approved/sendable-interior-mutability-proposal.md

Auto-implemented marker trait for types that can safely cross task boundaries.

trait Sendable {}

// Automatically Sendable when ALL conditions met:
// 1. All fields are Sendable
// 2. No interior mutability (only exists in runtime resources)
// 3. No non-Sendable captured state (for closures)

type Point = { x: int, y: int }  // Sendable: all fields are int
type Handle = { file: FileHandle }  // NOT Sendable

// Manual implementation is forbidden
impl MyType: Sendable { }  // ERROR: cannot implement Sendable manually

Interior mutability does not exist in user-defined Ori types. Only runtime-provided resources (FileHandle, Socket, etc.) have interior mutability because they wrap OS state. Channel endpoints (Producer, Consumer) ARE Sendable.

Implementation

17.2 Role-Based Channel Types

Split channels into Producer and Consumer roles with compile-time enforcement.

// Role-specific types
type Producer<T: Sendable>  // Can only send
type Consumer<T: Sendable>  // Can only receive

// Producer methods
impl<T: Sendable> Producer<T> {
    @send (self, value: T) -> void uses Async
    @close (self) -> void
    @is_closed (self) -> bool
}

// Consumer methods
impl<T: Sendable> Consumer<T> {
    @receive (self) -> Option<T> uses Async
    @is_closed (self) -> bool
}

// Consumer is Iterable
impl<T: Sendable> Iterable for Consumer<T> { ... }

Implementation

17.3 Channel Constructors

Four constructors for different concurrency patterns.

// One-to-one (exclusive, fastest)
@channel<T: Sendable> (buffer: int) -> (Producer<T>, Consumer<T>)

// Fan-in (many-to-one)
@channel_in<T: Sendable> (buffer: int) -> (CloneableProducer<T>, Consumer<T>)

// Fan-out (one-to-many)
@channel_out<T: Sendable> (buffer: int) -> (Producer<T>, CloneableConsumer<T>)

// Many-to-many (broadcast)
@channel_all<T: Sendable> (buffer: int) -> (CloneableProducer<T>, CloneableConsumer<T>)

Implementation

17.4 Ownership Transfer on Send

Values are consumed when sent, preventing data races.

@producer (p: Producer<Data>) -> void uses Async = {
    let data = create_data()
    p.send(value: data),  // Ownership transferred
    // data.field         // ERROR: 'data' moved into channel
}

Implementation

17.5 nursery Pattern

Structured concurrency with guaranteed task completion.

nursery(
    body: n -> for item in items do n.spawn(task: () -> process(item)),
    on_error: CollectAll,
    timeout: 30s,
)

type NurseryErrorMode = CancelRemaining | CollectAll | FailFast

Implementation

17.6 Parallel Execution Guarantees

Proposal: proposals/approved/parallel-execution-guarantees-proposal.md

Specifies execution guarantees for the parallel pattern: task ordering, concurrency limits, resource exhaustion, and timeout behavior.

Implementation

17.7 Nursery Cancellation Semantics

Proposal: proposals/approved/nursery-cancellation-proposal.md

Spec: spec/23-concurrency-model.md § Cancellation (added cooperative model, checkpoints, CancellationError, is_cancelled)

Specifies cooperative cancellation model, checkpoints, error mode behaviors, and cleanup guarantees.

Implementation

17.8 Timeout and Spawn Pattern Semantics

Proposal: proposals/approved/timeout-spawn-patterns-proposal.md

Formalizes semantics for timeout and spawn patterns including cancellation behavior, error handling, and task lifetime.

Timeout Pattern Implementation

Spawn Pattern Implementation

17.9 Section Completion Checklist

Exit Criteria: Can write producer/consumer pipeline with ownership safety and proper cancellation

Example: Worker Pool with Fan-In

@worker_pool (jobs: [Job]) -> [Result<Output, Error>] uses Async = {
    let (sender, receiver) = channel_in<Result<Output, Error>>(buffer: 100)

    nursery(
        body: n -> {
            // Spawn workers with cloned senders
            for i in 0..4 do
                n.spawn(task: () -> worker(sender.clone(), i))
            // Spawn job feeder
            n.spawn(task: () -> {
                for job in jobs do sender.send(value: Ok(job))
                sender.close()
            })
        }
        on_error: CollectAll
    )

    // Collect results
    for result in receiver yield result
}

Future Work (Deferred to Separate Proposals)

The following features are deferred to separate proposals:

Channel Select (Future Proposal)

select(
    recv(ch1) -> value: handle_ch1(value),
    recv(ch2) -> value: handle_ch2(value),
    after(5s): handle_timeout(),
)

Cancellation Tokens (Future Proposal)

let token = CancellationToken.new()
let child = token.child()
token.cancel()

Graceful Shutdown (Future Proposal)

on_signal(signal: SIGINT, handler: () -> shutdown.cancel())

See docs/ori_lang/proposals/approved/sendable-channels-proposal.md § Future Work for details.