Stdlib typed errors

Every fallible stdlib module declares its own typed error enum. Silt’s Result(T, ModuleError) return shape lets user code pattern-match the failure modes directly instead of substring-matching on a String payload. Each enum implements the built-in Error trait, which supertypes Display and provides a message() method so code that just wants a rendered error can fall back to "{e.message()}".

Variant naming

Every error enum is named after its module (io.IoError, tcp.TcpError), its variants carry no prefix (io.NotFound, tcp.Timeout), and its last variant is Other(String) for a failure that fits no other. An error enum and its variants are members of their module, reached through it, with or without the enum as a second qualifier:

import io

let a = io.NotFound("config.toml")

let b = io.IoError.NotFound("config.toml") -- same value

A selective import binds a variant by its bare name: import io.{ NotFound }. Two modules may have a variant of one name (tcp.Timeout and http.Timeout, Other in every module): a file imports at most one of them bare, and writes the others through their modules.

Enums

IoError (requires import io)

JsonError (requires import json)

TomlError (requires import toml)

IntError (requires import int)

Returned by int.parse.

FloatError (requires import float)

Returned by float.parse: the same variants as IntError, in a type of its own (float.Empty is not int.Empty).

HttpError (requires import http)

TcpError (requires import tcp)

PostgresError (requires import postgres)

TimeError (requires import time)

BytesError (requires import bytes)

TaskError (requires import task)

Returned by task.deadline.

EncodingError (requires import encoding)

Returned by encoding.url_decode and encoding.form_decode.

CryptoError (requires import crypto)

Returned by crypto.random_bytes.

UuidError (requires import uuid)

Returned by uuid.parse.

RegexError (requires import regex)

Returned by every regex.* function for a pattern that does not compile.

Example: user-side pattern matching

import io

fn handle(e: io.IoError) -> String {
  match e {
    io.NotFound(path) -> "missing: {path}"
    io.PermissionDenied(path) -> "denied: {path}"
    io.AlreadyExists(_) | io.InvalidInput(_) -> "recoverable"
    io.Interrupted | io.UnexpectedEof | io.WriteZero -> "transient"
    io.Other(msg) -> "unknown: {msg}"
  }
}

fn main() {
  println(handle(io.NotFound("config.toml")))
}

Cross-module composition

Silt does not auto-convert between error types. A function that spans several stdlib modules wraps each module’s error in a local AppError enum and lifts each call’s Err into it with result.map_err. Variant constructors are first-class Fn(e) -> f values, so the second argument is just the constructor name — no closure wrapper needed:

import io
import json
import result

type Config {
  host: String,
  port: Int,
}

type AppError {
  IoProblem(io.IoError),
  JsonProblem(json.JsonError),
}

fn load_config(path: String) -> Result(Config, AppError) {
  let raw = io.read_file(path) |> result.map_err(IoProblem)?
  let cfg = json.parse(raw, Config) |> result.map_err(JsonProblem)?
  Ok(cfg)
}

A ? that ends a pipeline applies to the whole pipeline, so the pipeline is a single expression terminated by ?. See examples/cross_module_errors.silt for a longer walkthrough. A separate proposal (error-from-trait.md) tracks the design for a .into()-based ergonomics layer over this pattern.