239 Expert

Strong Profunctor

Functional Programming

Tutorial Video

Text description (accessibility)

This video demonstrates the "Strong Profunctor" functional Rust example. Difficulty level: Expert. Key concepts covered: Functional Programming. A `Strong` profunctor extends a profunctor with `first: P<A, B> -> P<(A, C), (B, C)>` — the ability to "pass along" extra context `C` while the profunctor operates on `A -> B`. Key difference from OCaml: 1. **Lens encoding**: `Strong` captures exactly what makes lenses work; functions are Strong, making the function profunctor the reference implementation.

Tutorial

The Problem

A Strong profunctor extends a profunctor with first: P<A, B> -> P<(A, C), (B, C)> — the ability to "pass along" extra context C while the profunctor operates on A -> B. Functions are Strong: first(f) = |(a, c)| (f(a), c). The significance: in the profunctor optics encoding, lenses are exactly Strong profunctors. A Van Laarhoven lens type Lens s a = ∀p. Strong p => p a b -> p s t works for any Strong profunctor.

🎯 Learning Outcomes

• Understand Strong as the profunctor class that captures lens-like behavior

• Learn first and second as the two Strong operations

• See how functions implement Strong by threading context through

• Connect Strong to lens encoding: lenses are polymorphic over all Strong profunctors

Code Example

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

(* A strong profunctor can carry extra information through computation.
   first  :: p a b -> p (a * c) (b * c)
   second :: p a b -> p (c * a) (c * b)
   Enables building lenses! *)

(* Functions form a strong profunctor *)
let first  f (a, c) = (f a, c)
let second f (c, a) = (c, f a)

(* Lens from strong profunctor *)
(* A lens s a = forall p. Strong p => p a a -> p s s *)
(* Simplified: a pair of get/set *)
type ('s, 'a) lens = {
  get : 's -> 'a;
  set : 'a -> 's -> 's;
}

let view lens s = lens.get s
let over lens f s = lens.set (f (lens.get s)) s
let set  lens a s = lens.set a s

(* Compose lenses *)
let compose l1 l2 = {
  get = (fun s -> l2.get (l1.get s));
  set = (fun a s -> l1.set (l2.set a (l1.get s)) s);
}

type person = { name: string; age: int }
type company = { ceo: person; revenue: int }

let name_lens = { get = (fun p -> p.name); set = (fun n p -> { p with name = n }) }
let ceo_lens  = { get = (fun c -> c.ceo);  set = (fun p c -> { c with ceo = p }) }
let ceo_name  = compose ceo_lens name_lens

let () =
  let c = { ceo = { name = "Alice"; age = 45 }; revenue = 1_000_000 } in
  Printf.printf "CEO: %s\n" (view ceo_name c);
  let c' = set ceo_name "Bob" c in
  Printf.printf "New CEO: %s\n" (view ceo_name c');
  let c'' = over ceo_lens (fun p -> { p with age = p.age + 1 }) c in
  Printf.printf "CEO age after bday: %d\n" c''.ceo.age

Key Differences

Lens encoding: Strong captures exactly what makes lenses work; functions are Strong, making the function profunctor the reference implementation.

**first vs. second**: Both are derivable from each other given swap: second p = dimap swap swap (first p) — only one needs to be primitive.

Profunctor class hierarchy: Strong extends Profunctor; Choice extends Profunctor for prisms; their intersection is affine traversals.

Type complexity: The profunctor optics encoding requires rank-2 types for the full elegance; Rust and OCaml approximate it.

OCaml Approach

OCaml's Strong profunctor:

module type STRONG = sig
  include PROFUNCTOR
  val first : ('a, 'b) t -> ('a * 'c, 'b * 'c) t
  val second : ('a, 'b) t -> ('c * 'a, 'c * 'b) t
end

Lenses in the profunctor encoding: type ('s, 't, 'a, 'b) lens = { run : 'p. (module STRONG with type ('a,'b) t = 'p) -> 'p a b -> 'p s t }. This requires first-class modules and rank-2 types — OCaml handles this more naturally than Rust.

Full Source

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

(* A strong profunctor can carry extra information through computation.
   first  :: p a b -> p (a * c) (b * c)
   second :: p a b -> p (c * a) (c * b)
   Enables building lenses! *)

(* Functions form a strong profunctor *)
let first  f (a, c) = (f a, c)
let second f (c, a) = (c, f a)

(* Lens from strong profunctor *)
(* A lens s a = forall p. Strong p => p a a -> p s s *)
(* Simplified: a pair of get/set *)
type ('s, 'a) lens = {
  get : 's -> 'a;
  set : 'a -> 's -> 's;
}

let view lens s = lens.get s
let over lens f s = lens.set (f (lens.get s)) s
let set  lens a s = lens.set a s

(* Compose lenses *)
let compose l1 l2 = {
  get = (fun s -> l2.get (l1.get s));
  set = (fun a s -> l1.set (l2.set a (l1.get s)) s);
}

type person = { name: string; age: int }
type company = { ceo: person; revenue: int }

let name_lens = { get = (fun p -> p.name); set = (fun n p -> { p with name = n }) }
let ceo_lens  = { get = (fun c -> c.ceo);  set = (fun p c -> { c with ceo = p }) }
let ceo_name  = compose ceo_lens name_lens

let () =
  let c = { ceo = { name = "Alice"; age = 45 }; revenue = 1_000_000 } in
  Printf.printf "CEO: %s\n" (view ceo_name c);
  let c' = set ceo_name "Bob" c in
  Printf.printf "New CEO: %s\n" (view ceo_name c');
  let c'' = over ceo_lens (fun p -> { p with age = p.age + 1 }) c in
  Printf.printf "CEO age after bday: %d\n" c''.ceo.age

Deep Comparison

OCaml vs Rust: Strong Profunctor

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 Strong for Parser<A, B> (from example 238) — running a parser while threading context through.

Write lens_via_strong(get, set) that creates a lens from get/set pair using the Strong profunctor encoding.

Verify that second(f) = dimap(swap, swap)(first(f)) produces the same result as a direct second implementation.

Open Source Repos

functional-rust

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

Rust