190 Expert

Effect Handlers

Functional Programming

Tutorial Video

Text description (accessibility)

This video demonstrates the "Effect Handlers" functional Rust example. Difficulty level: Expert. Key concepts covered: Functional Programming. An effect handler is the runtime component that intercepts effects, provides a value, and resumes the computation. Key difference from OCaml: 1. **Handler composition**: OCaml's nested `match_with` calls compose handlers automatically; Rust's simulation requires explicit forwarding of unhandled effects.

Tutorial

The Problem

An effect handler is the runtime component that intercepts effects, provides a value, and resumes the computation. Different handlers for the same effects give different behaviors — the same program can run in a logging context, a testing context, or a production context. This is the effect-system equivalent of the free monad interpreter pattern, but operating at the runtime level rather than the data-structure level.

🎯 Learning Outcomes

• Implement effect handlers as closures that intercept and respond to effects

• See how swapping handlers changes program behavior without modifying the program

• Learn how handlers compose (nested handlers for multiple effects)

• Understand the relationship between effect handlers and exception handlers

Code Example

#![allow(clippy::all)]
// Stub — awaiting conversion from OCaml source.

(* Effect handlers: intercept performed effects and decide how to resume.
   The handler has access to the delimited continuation 'k'. *)

(* A logging effect *)
effect Log : string -> unit

(* A nondeterminism effect: choose one of two values *)
effect Choose : 'a list -> 'a

(* Run with logging to a buffer *)
let collect_logs program =
  let log = ref [] in
  let result = match program () with
    | v -> v
    | effect (Log msg) k ->
      log := msg :: !log;
      continue k ()
  in
  (result, List.rev !log)

(* Run nondeterministically: return ALL results *)
let run_all program =
  match program () with
  | v -> [v]
  | effect (Choose xs) k ->
    List.concat_map (fun x -> continue k x) xs

let () =
  (* Logging handler *)
  let program1 () =
    perform (Log "starting");
    let x = 42 in
    perform (Log (Printf.sprintf "x = %d" x));
    perform (Log "done");
    x * 2
  in
  let (result, logs) = collect_logs program1 in
  Printf.printf "result=%d, logs=[%s]\n" result (String.concat "; " logs);

  (* Nondeterminism handler *)
  let program2 () =
    let x = perform (Choose [1; 2; 3]) in
    let y = perform (Choose [10; 20]) in
    x + y
  in
  let results = run_all program2 in
  Printf.printf "all results: [%s]\n" (String.concat "; " (List.map string_of_int results))

Key Differences

Handler composition: OCaml's nested match_with calls compose handlers automatically; Rust's simulation requires explicit forwarding of unhandled effects.

Effect typing: OCaml's effect type system (planned for OCaml 5.x) will statically type which effects a function performs; Rust's simulation is untyped.

Resumption semantics: OCaml's handlers can resume the computation at the point of the effect; Rust's simulation uses callback functions instead.

Standard uses: OCaml's async concurrency (eio) is built on effects; Rust's async/await uses a different mechanism (state machine transformation).

OCaml Approach

OCaml 5's match_with is the native handler:

let with_state initial program =
  let state = ref initial in
  match_with program ()
    { effc = fun (type a) (eff : a eff) ->
        match eff with
        | Get -> Some (fun k -> continue k !state)
        | Put v -> Some (fun k -> state := v; continue k ())
        | _ -> None }

Nested match_with handlers compose naturally — each handles its own effects and forwards others upward.

Full Source

#![allow(clippy::all)]
// Stub — awaiting conversion from OCaml source.

(* Effect handlers: intercept performed effects and decide how to resume.
   The handler has access to the delimited continuation 'k'. *)

(* A logging effect *)
effect Log : string -> unit

(* A nondeterminism effect: choose one of two values *)
effect Choose : 'a list -> 'a

(* Run with logging to a buffer *)
let collect_logs program =
  let log = ref [] in
  let result = match program () with
    | v -> v
    | effect (Log msg) k ->
      log := msg :: !log;
      continue k ()
  in
  (result, List.rev !log)

(* Run nondeterministically: return ALL results *)
let run_all program =
  match program () with
  | v -> [v]
  | effect (Choose xs) k ->
    List.concat_map (fun x -> continue k x) xs

let () =
  (* Logging handler *)
  let program1 () =
    perform (Log "starting");
    let x = 42 in
    perform (Log (Printf.sprintf "x = %d" x));
    perform (Log "done");
    x * 2
  in
  let (result, logs) = collect_logs program1 in
  Printf.printf "result=%d, logs=[%s]\n" result (String.concat "; " logs);

  (* Nondeterminism handler *)
  let program2 () =
    let x = perform (Choose [1; 2; 3]) in
    let y = perform (Choose [10; 20]) in
    x + y
  in
  let results = run_all program2 in
  Printf.printf "all results: [%s]\n" (String.concat "; " (List.map string_of_int results))

Deep Comparison

OCaml vs Rust: Effect Handler

Overview

See the example.rs and example.ml files for detailed implementations.

Key Differences

Aspect	OCaml	Rust
Type system	Hindley-Milner	Ownership + traits
Memory	GC	Zero-cost abstractions
Mutability	Explicit ref	mut keyword
Error handling	Option/Result	Result<T, E>

See README.md for detailed comparison.

Exercises

Implement a with_transaction handler that wraps all state operations in a simulated transaction, rolling back on error.

Write a handler that counts the number of each effect type performed.

Compose two handlers: one for logging and one for state, showing that both can intercept their respective effects on the same program.

Open Source Repos

functional-rust

View the source for this example on GitHub — OCaml and Rust side by side in the repo.

Rust