Performance

Benchmark comparing Skuld against pure baselines and minimal effect implementations. Run with mix run bench/skuld_benchmark.exs.

What's being measured: A loop that increments a counter from 0 to N using State.get() / State.put(n + 1) operations. This exercises the core effect invocation path repeatedly, measuring per-operation overhead.

Core Benchmark

Implementations compared:

• Pure/Rec - Non-effectful baseline using tail recursion with map state
• Monad - Simple state monad (fn state -> {val, state} end) with no effect system
• Evf - Flat evidence-passing, direct-style (no CPS) - can't support control effects
• Evf/CPS - Flat evidence-passing with CPS - isolates CPS overhead (~1.1x vs Evf)
• Skuld/Nest - Skuld with nested Comp.bind calls (typical usage pattern)
• Skuld/FxFL - Skuld with FxFasterList iteration (optimized for collections)

Iteration Strategies

Iteration options:

• FxFasterList - Uses Enum.reduce_while, fastest option (~2x faster than FxList)
• FxList - Uses Comp.bind chains, supports full Yield/Suspend resume semantics
• Yield - Coroutine-style suspend/resume, use when you need interruptible iteration

All three maintain constant per-operation cost as N grows.

Key Takeaways

1. CPS overhead is minimal - Evf/CPS is only ~1.1x slower than direct-style Evf
2. Skuld overhead (~7x vs Evf/CPS) comes from scoped handlers, exception handling, and auto-lifting
3. FxFasterList is the fastest iteration strategy when you don't need Yield semantics
4. Per-op cost is constant - no quadratic blowup at scale

Real-World Perspective

These benchmarks represent a worst-case scenario where computations do almost nothing except exercise the effects machinery. In practice, algebraic effects compose real work - serialization, domain calculations, transcoding - where actual computation dominates execution time.

For example, JSON encoding a moderate payload takes 10-100us, and domain validation or business logic involves similar compute. Compared to Skuld's ~0.1us per effect invocation, even dozens of effect operations add negligible overhead to real workloads. The architectural benefits - testability, composability, separation of concerns - far outweigh the microsecond-level cost.