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)

Verification (2026-03-29): Status not-started CONFIRMED. No substantive implementation exists. Existing scaffolding (FunctionExpKind variants for channel/parallel/spawn/timeout, Tag::Channel, Sendable registered in well-known traits, sequential stubs in evaluator) does not constitute meaningful progress. Section 16 (Async Support) is also not-started — a prerequisite blocker.

10 gaps identified (see .verify-results/section-17-results.md):

GAP-17-001: nursery not parseable — no FunctionExpKind::Nursery variant

GAP-17-002: Channel constructor evaluator gap — parsed but no eval dispatch

GAP-17-003: Spec clause numbering drift — plan says 23, actual is 22 (FIXED in this update)

GAP-17-004: No Sendable auto-derivation logic (expected for not-started)

GAP-17-005: Channel type representation incomplete — single Tag::Channel vs 4 role-based types

GAP-17-006: No stdlib concurrency types — CancellationError/CancellationReason/NurseryErrorMode missing from prelude

GAP-17-007: is_cancelled() not implemented in any compiler crate

GAP-17-008: Section 16 dependency not started — prerequisite blocker

GAP-17-009: 30+ planned Rust test file paths reference non-existent modules/directories

GAP-17-010: All concurrency spec tests commented out (3 files with extensive inactive test code)

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.

Verification (2026-03-29): 0/10 done, 1 partial (closure capture-by-value exists in eval via environment/mod.rs capture() but has no dedicated test/verification infrastructure). No task abstraction, async context, or suspension analysis exists in any crate. ori_rt uses non-atomic refcounting throughout. No tests/spec/concurrency/ directory exists.

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.

Verification (2026-03-29): 0/5 done, 1 partial. Sendable IS registered in well-known traits (ori_types/src/check/well_known/mod.rs:108, Duration/Size have it in trait sets). However: no auto-implementation logic, no field-recursive analysis, no enforcement at channel/spawn boundaries. Registered as a trait name only — NOT semantically implemented. Commented-out #compile_fail("not Sendable") test exists in channels.ori line 162-166.

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.

Verification (2026-03-29): 0/5 done. No Producer<T>, Consumer<T>, CloneableProducer<T>, CloneableConsumer<T> types exist. Tag::Channel (value 19) in ori_types/src/tag/mod.rs is a single generic chan<T> — the old undifferentiated channel, not the role-based split. All channel type tests in channels.ori are commented out.

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

Verification (2026-03-29): 0/5 done, 1 partial. FunctionExpKind has Channel/ChannelIn/ ChannelOut/ChannelAll variants (parser can parse them), but the evaluator (function_exp.rs) has NO match arms for these — any Ori program using channel<T>(buffer: N) would hit a missing match arm at runtime. GAP-17-002.

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

Verification (2026-03-29): 0/3 done. No move semantics on channel send. No use-after-send analysis. tests/compile-fail/use_after_send.ori does not exist.

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

Verification (2026-03-29): 0/8 done. PREREQUISITE GAP: FunctionExpKind has NO Nursery variant — the parser CANNOT parse nursery(...). GAP-17-001. The formatter (ori_fmt/src/packing/construct.rs) recognizes ConstructKind::Nursery for formatting scaffolding only. No Nursery type, no NurseryErrorMode sum type, no nursery evaluation. All nursery tests in channels.ori (lines 172-246) are commented out.

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.

Verification (2026-03-29): 0/6 done, 1 partial. The stub in function_exp.rs:219-237 iterates tasks in list order (sequential) — trivially satisfies start order but is NOT concurrent execution. max_concurrent, timeout, resource exhaustion, and empty list handling are all unimplemented. All parallel tests in parallel.ori are commented out; active tests use for...yield as sequential simulation.

Implementation

17.7 Nursery Cancellation Semantics

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

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

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

Verification (2026-03-29): 0/8 done. Spec (Clause 22.7) is well-written with checkpoints, CancellationError/CancellationReason types, error mode semantics, timeout cancellation, and cleanup guarantees — most complete part of the concurrency story. But: is_cancelled() is NOT implemented in any compiler crate despite being documented in CLAUDE.md and ori-syntax.md. No CancellationError or CancellationReason types in library/std/prelude.ori or compiler. Single commented-out is_cancelled test in channels.ori (lines 252-255). DRIFT FIXED: was referencing spec/23-concurrency-model.md, actual file is spec/22-concurrency-model.md.

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.

Verification (2026-03-29): 0/12 done, 2 partial. timeout stub executes operation, wraps in Ok(), ignores timeout duration — no CancellationError return. spawn stub executes tasks sequentially, ignores errors, returns Void. Neither implements actual concurrency. All timeout and spawn tests in concurrency.ori and parallel.ori are commented out.

Timeout Pattern Implementation

Spawn Pattern Implementation

17.9 Section Completion Checklist

Verification (2026-03-29): 0/16 done. Consistent with overall not-started status.

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

Subsection close-out (17.9) — MANDATORY before starting the next subsection. Run /improve-tooling retrospectively on THIS subsection’s debugging journey (per .claude/skills/improve-tooling/SKILL.md “Per-Subsection Workflow”): which diagnostics/ scripts you ran, where you added dbg!/tracing calls, where output was hard to interpret, where test failures gave unhelpful messages, where you ran the same command sequence repeatedly. Forward-look: what tool/log/diagnostic would shorten the next regression in this code path by 10 minutes? Implement improvements NOW (zero deferral) and commit each via SEPARATE /commit-push using a valid conventional-commit type (build(diagnostics): ... — surfaced by section-17.9 retrospective — build/test/chore/ci/docs are valid; tools(...) is rejected by the lefthook commit-msg hook). Mandatory even when nothing felt painful. If genuinely no gaps, document briefly: “Retrospective 17.9: no tooling gaps”. Update this subsection’s status in section frontmatter to complete.
/sync-claude section-close doc sync — verify Claude artifacts across all section commits. Map changed crates to rules files, check CLAUDE.md, canon.md. Fix drift NOW.
Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files.

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.