Fundamentals

effect IO with one operation; handler returns a default string.

// Feature: algebraic effects — declare, perform, handle

// Syntax: `effect Name { fn op(...) -> T }` declares; `perform Name::op(...)`

// raises; `handle expr with { Name::op(args) => ... }` interprets.

// When to use: dependency-inject impure ops (IO, logging, time,

// randomness) without dragging trait objects through every call.


effect IO {
  fn read(path: str) -> str
}

// `with IO` says: this function performs at least one IO effect.

fn read_config() with IO -> str {
  return perform IO::read("config.toml")
}

// The handler block decides what `IO::read` actually means.

let result = handle read_config() with {
  IO::read(path) => "default config from {path}",
}

print(result)
// expected: default config from config.toml

Logger with info/warn; the handler dispatches each one to print.

// Feature: effect with multiple operations

// Syntax: an `effect` block can declare several `fn` operations;

// the handler must provide a clause for every operation that

// the effectful code may `perform`.

// When to use: a coherent capability — e.g. a Logger with `info`/`warn`/`error`

// — that you want to swap atomically (test logger, file logger, …).


effect Logger {
  fn info(msg: str)
  fn warn(msg: str)
}

fn run() with Logger {
  perform Logger::info("starting")
  perform Logger::warn("careful")
  perform Logger::info("done")
}

handle run() with {
  Logger::info(msg) => print("[INFO] {msg}"),
  Logger::warn(msg) => print("[WARN] {msg}"),
}
// expected:

//   [INFO] starting

//   [WARN] careful

//   [INFO] done

Math effect with add and double; handler computes the real result from the arguments.

// Feature: handler clauses can use the operation arguments

// Syntax: each clause `Op(arg1, arg2) => <expr>` binds the args

// and the expression's value is the result of `perform`.

// When to use: any effect where the result depends on the input —

// pure mocks, deterministic stubs, computed responses.


effect Math {
  fn add(a: int, b: int) -> int
  fn double(n: int) -> int
}

fn compute() with Math -> int {
  let x = perform Math::add(2, 3)
  let y = perform Math::double(x)
  return y
}

let result = handle compute() with {
  Math::add(a, b) => a + b,
  Math::double(n) => n * 2,
}
print(result)
// expected: 10