Effects

Algebraic effects let a function declare a side requirement without knowing how it will be satisfied. The handler decides, and can resume execution from the perform site.

The idea

Exceptions let a function abort up the call stack. Effects go further: the handler can send a value back down to the point where the effect was performed, and execution continues from there. This makes effects useful for dependency injection, logging, non-determinism, and custom control flow.

Declare, perform, handle

There are three steps. First, declare the effect as a named interface:

effect Ask {
  fn prompt(msg) -> str
}

Second, perform the effect inside a function. The function does not know or care how Ask.prompt is implemented:

fn greet() {
  let name = perform Ask.prompt("name?")
  return "Hello, {name}!"
}

Third, wrap the call in a handle block that provides the implementation:

effect Ask {
  fn prompt(msg) -> str
}

fn greet() {
  let name = perform Ask.prompt("name?")
  return "Hello, {name}!"
}

let result = handle greet() {
  Ask.prompt(msg) => resume("World")
}
println(result)                  -- Hello, World!

Resuming with a value

resume(value) inside a handler arm sends the value back to the perform site. Execution of the performing function continues from the next statement after the perform.

effect Rand {
  fn next_int(lo, hi) -> int
}

fn roll_dice() {
  let a = perform Rand.next_int(1, 6)
  let b = perform Rand.next_int(1, 6)
  return a + b
}

-- deterministic handler for testing
let result = handle roll_dice() {
  Rand.next_int(lo, hi) => resume(3)
}
println(result)                  -- 6 (always 3 + 3)

Accumulating effects

The handler body runs every time the effect is performed. You can use this to collect values, count calls, or build up a result.

effect Log {
  fn log(msg)
}

var logs = []
handle {
  perform Log.log("first")
  perform Log.log("second")
  perform Log.log("third")
} {
  Log.log(msg) => {
    logs.push(msg)
    resume(null)
  }
}
println(logs)                    -- ["first", "second", "third"]

The handle form accepts a block as the computation, not just a function call.

Multi-shot resume

A handler arm can call resume more than once. Each call re-enters the captured continuation, running the rest of the computation again with the new value. This is the basis for non-determinism and search.

effect Choose {
  fn pick() -> int
}

fn compute() {
  let x = perform Choose.pick()
  return x * 10
}

var results = []
handle {
  let r = compute()
  results.push(r)
} {
  Choose.pick() => {
    resume(1)
    resume(2)
    resume(3)
  }
}
println(results)                 -- [10, 20, 30]

Effects vs. exceptions

Exceptions abort and unwind; there is no way to resume. Effects are resumable: the handler gets control, does something, and hands control back to the performing function. Use exceptions when the error is unrecoverable at the call site; use effects when the callee needs information or a capability that the caller should supply.