243 Expert

Environment Comonad

Functional Programming

Tutorial Video

Text description (accessibility)

This video demonstrates the "Environment Comonad" functional Rust example. Difficulty level: Expert. Key concepts covered: Functional Programming. The Environment comonad (also called the Reader comonad's dual, or Co-Reader) pairs a value with a fixed environment: `(e, a)`. Key difference from OCaml: | Aspect | Rust | OCaml |

Tutorial

The Problem

The Environment comonad (also called the Reader comonad's dual, or Co-Reader) pairs a value with a fixed environment: (e, a). You can always extract the value, ask what the environment is, and extend computations that depend on both the current value and the surrounding environment. This models read-only context propagation where each step in a computation can inspect a shared environment without passing it explicitly.

🎯 Learning Outcomes

• Understand Env as the categorical dual of the Reader monad

• Implement extract, extend, and duplicate for the Env comonad

• See how ask retrieves the environment and local modifies it

• Compare the Env comonad with OCaml's equivalent using tuples and modules

• Recognize when Env comonad is more natural than threading an explicit config argument

Code Example

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

(* Env comonad (also called CoReader): pairs a value with a read-only environment.
   Dual of the Reader monad.
   extract: get the value (ignoring environment)
   extend: access the environment while computing *)

type ('e, 'a) env = Env of 'e * 'a

let ask     (Env (e, _)) = e
let extract (Env (_, a)) = a

let extend (Env (e, a)) f =
  Env (e, f (Env (e, a)))

(* A simple expression evaluator with environment *)
type expr =
  | Lit of int
  | Var of string
  | Add of expr * expr
  | Mul of expr * expr

type env_map = (string * int) list

let rec eval_expr (Env (env, expr)) =
  match expr with
  | Lit n        -> n
  | Var x        -> List.assoc x env
  | Add (l, r)   ->
    eval_expr (Env (env, l)) + eval_expr (Env (env, r))
  | Mul (l, r)   ->
    eval_expr (Env (env, l)) * eval_expr (Env (env, r))

let () =
  let env = [("x", 10); ("y", 3); ("z", 7)] in

  let e1 = Add (Var "x", Mul (Lit 2, Var "y")) in (* x + 2*y = 16 *)
  let result1 = eval_expr (Env (env, e1)) in
  Printf.printf "x + 2*y = %d\n" result1;

  let e2 = Mul (Add (Var "x", Var "z"), Var "y") in (* (x+z)*y = 51 *)
  let result2 = eval_expr (Env (env, e2)) in
  Printf.printf "(x+z)*y = %d\n" result2;

  (* Extend: derive new computation from environment *)
  let w = Env (env, "x") in
  let w' = extend w (fun (Env (e, k)) -> List.assoc k e * 2) in
  Printf.printf "x * 2 via extend = %d\n" (extract w')

Key Differences

Aspect	Rust	OCaml
Environment sharing	`E: Clone` on each operation	implicit GC sharing
Local transformation	returns `Env<E2, A>` (new type)	returns same `env` type
Duplicate	requires `A: Clone`	structural copy
Composition	`.extend(f).extend(g)` chains	same, pipe-friendly
Adjunction	dual to `State` monad	same theoretical dual

The Env comonad is adjoint to the State monad: Env extracts a value from context while State injects a state into continuation. Together they form the (- × e) ⊣ (e →) adjunction.

OCaml Approach

OCaml represents Env as a plain pair:

type ('e, 'a) env = { env: 'e; val_: 'a }

let extract { val_; _ } = val_
let ask { env; _ } = env

let extend f w = { env = w.env; val_ = f w }
let duplicate w = { env = w.env; val_ = w }
let local f w = { env = f w.env; val_ = w.val_ }

OCaml's implicit polymorphism avoids the Clone constraints Rust requires. The tradeoff is that OCaml's type inference handles the variance silently while Rust makes it explicit.

Full Source

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

(* Env comonad (also called CoReader): pairs a value with a read-only environment.
   Dual of the Reader monad.
   extract: get the value (ignoring environment)
   extend: access the environment while computing *)

type ('e, 'a) env = Env of 'e * 'a

let ask     (Env (e, _)) = e
let extract (Env (_, a)) = a

let extend (Env (e, a)) f =
  Env (e, f (Env (e, a)))

(* A simple expression evaluator with environment *)
type expr =
  | Lit of int
  | Var of string
  | Add of expr * expr
  | Mul of expr * expr

type env_map = (string * int) list

let rec eval_expr (Env (env, expr)) =
  match expr with
  | Lit n        -> n
  | Var x        -> List.assoc x env
  | Add (l, r)   ->
    eval_expr (Env (env, l)) + eval_expr (Env (env, r))
  | Mul (l, r)   ->
    eval_expr (Env (env, l)) * eval_expr (Env (env, r))

let () =
  let env = [("x", 10); ("y", 3); ("z", 7)] in

  let e1 = Add (Var "x", Mul (Lit 2, Var "y")) in (* x + 2*y = 16 *)
  let result1 = eval_expr (Env (env, e1)) in
  Printf.printf "x + 2*y = %d\n" result1;

  let e2 = Mul (Add (Var "x", Var "z"), Var "y") in (* (x+z)*y = 51 *)
  let result2 = eval_expr (Env (env, e2)) in
  Printf.printf "(x+z)*y = %d\n" result2;

  (* Extend: derive new computation from environment *)
  let w = Env (env, "x") in
  let w' = extend w (fun (Env (e, k)) -> List.assoc k e * 2) in
  Printf.printf "x * 2 via extend = %d\n" (extract w')

Deep Comparison

OCaml vs Rust: Env Comonad

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 fmap for Env<E, A> that maps the value while keeping the environment unchanged.

Verify the comonad laws: extend extract = id, extract . extend f = f, extend f . extend g = extend (f . extend g).

Build a dependency injection container using Env<AppConfig, Service> where each extend step configures a new service layer.

Implement asks: given a function E -> B, produce Env<E, B> — the comonadic equivalent of Reader's asks.

Show the adjunction between Env and State by implementing unit and counit of the adjunction and checking the triangle identities.

Open Source Repos

functional-rust

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

Rust