Module error

Type-erased dynamic error type. Wraps any type implementing Error.

An error that adds a message to the one underneath it — Rust's anyhow::Context / .context(...).

This is the type that makes Error.source worth having: nothing else in the tree overrides it, so before this every error chain was one link long. to_string renders the whole chain, innermost last:

e := Context.new(`while loading the config`, dyn(io_err));
println(e.to_string());   // while loading the config: no such file

Non-resumable exception handling effect record. Use throw to raise an AnyError and abort the current computation. throw is ctl(...) — handler body may contain unwind, and the handler value is frame-bound (see plans/archive/EXPLICIT_EFFECTS.md §4).

Creates a resumable exception effect record parameterized by the resume type. Unlike Exception, the handler can return a value to resume the computation. throw is still ctl(...) because the handler MAY choose to unwind; regular fn returns are also valid via subtyping fn <: ctl.

An iterator over an error and everything underneath it — Rust's anyhow::Error::chain / std::error::Report's walk.

The first next() yields the error the chain was built from, then each source() in turn, ending when one reports .None. So a chain always has at least one link.

{ error_chain } :: import("std/error");

(e : AnyError) = dyn(Context.new(`while loading config`, io_err));
(n : usize) = usize(0);
it := error_chain(e);
(going : bool) = true;
while(runtime(going), {
  match(it.next(), .Some(link) => { n = (n + usize(1)); }, .None => { going = false; });
});

The cursor is spelled with match rather than Option's inherent methods throughout: Option(Dyn(Trait)) cannot take one — the specialization is called but never emitted, so the C fails to compile (issues/fixed/option-of-a-trait-object-never-emits-its-inherent-methods.md).

Standard error trait for typed error propagation. All error types should implement this trait along with ToString.

Common effect bundle: Io + Exception. Used as the effect parameter for Futures that perform Io and may throw. Construct with { io, exn }; project with e.io or e.exn. The innermost error in a chain — Rust's anyhow::Error::root_cause.

Follows source() until an error reports none, and returns that one. An error with nothing underneath it is its own root cause, so this never returns .None and callers need no unwrapping.

{ root_cause } :: import("std/error");
e := dyn(Context.new(`while loading the config`, dyn(io_err)));
println(root_cause(e).to_string());   // the io error, not the context

Spelled with match rather than Option methods deliberately: the result of source() is an Option(Dyn(Error)), and an Option of a trait object cannot take an inherent Option method — the specialization is called but never emitted, so the C fails to compile (issues/fixed/option-of-a-trait-object-never-emits-its-inherent-methods.md). That is a separate open defect; this walk stays clear of it.

Start a chain at err. The first next() returns err itself.