Crate sans 

Sans: Composable Coroutine-Based Programming

Build composable computations that can yield intermediate values and be driven to completion by external input.

Core Traits

• Sans<I, O>: Stateful computations that process input and yield values
• InitSans<I, O>: Computations that provide initial output before processing input

Key Features

• Composable: Chain coroutines together with .chain()
• Transformable: Use .map_input(), .map_yield(), .map_done()
• Async Support: Both sync and async execution with handle() and handle_async()

Example

use sans::prelude::*;

// Build a pipeline that yields initial value, processes input, then finishes
let pipeline = init_once(10, |x: i32| x * 2)  // Yields 10, then multiplies input by 2
    .chain(once(|x: i32| x + 1));              // Adds 1 to input, then completes

// Drive the pipeline with responses to each yield
let result = handle(pipeline, |output| output + 5);

Module Organization

This library is organized by capability:

• build - Creating new coroutines
• compose - Chaining and transforming coroutines
• result - Result combinators for error handling in coroutines
• poll - Universal adapter implementing both Sans and InitSans for bridging APIs
• concurrent - Running multiple coroutines concurrently
• sequential - Running coroutines one after another
• run - Executing coroutine pipelines
• iter - Iterator adapters for Sans<(), O> and InitSans<(), O>
• prelude - Common imports for quick start

Common Functions

Building Coroutines:

• once(f) - Apply function once, then complete
• repeat(f) - Apply function repeatedly
• init(value, coroutine) - Wrap a Sans with an initial output (for and_then)
• init_once(value, f) - Yield initial value, then apply function once
• chain(a, b) - Run coroutine a to completion, then run coroutine b

Execution:

• handle(coroutine, responder) - Drive computation with sync responses
• handle_async(coroutine, responder) - Drive computation with async responses

Modules

build

Building coroutines from scratch

compose

Combining coroutines together

concurrent

Run multiple coroutines concurrently

iter

Iterator adapters for Sans coroutines with unit input.

poll

Polling for both Sans and InitSans

prelude

Commonly used imports

result

Result combinators for error handling in coroutines.

run

Running coroutines to completion

sequential

Run coroutines one after another

Structs

PoisonError

Enums

Step

Result of a computation step, either yielding a value to continue or completing with a final value.

Traits

InitSans

Computations that yield an initial value before processing input.

Sans

Core trait for stateful computations that process input and yield intermediate values.