240 Expert

Choice Profunctor

Functional Programming

Tutorial Video

Text description (accessibility)

This video demonstrates the "Choice Profunctor" functional Rust example. Difficulty level: Expert. Key concepts covered: Functional Programming. While `Strong` profunctors correspond to lenses (product types, always present), `Choice` profunctors correspond to prisms (sum types, possibly absent). Key difference from OCaml: 1. **Prism encoding**: `Choice` captures prisms just as `Strong` captures lenses; the duality (products vs. sums) maps onto profunctor classes.

Tutorial

The Problem

While Strong profunctors correspond to lenses (product types, always present), Choice profunctors correspond to prisms (sum types, possibly absent). Choice adds left: P<A, B> -> P<Either<A, C>, Either<B, C>> — the ability to "pass through" the Right(C) case while operating on Left(A) -> Left(B). Functions implement Choice naturally. A Van Laarhoven prism requires Choice: type Prism s a = ∀p. Choice p => p a b -> p s t.

🎯 Learning Outcomes

• Understand Choice as the profunctor class capturing prism-like behavior

• Learn left and right as the two Choice operations

• See how Choice enables "operate on one branch, pass through the other"

• Connect Choice to prisms: prisms are polymorphic over all Choice profunctors

Code Example

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

(* Choice profunctor: can be applied to one side of a sum type.
   left  :: p a b -> p (a + c) (b + c)
   right :: p a b -> p (c + a) (c + b)
   Enables building prisms! *)

(* Functions form a choice profunctor *)
let left  f = function Left a  -> Left (f a)  | Right c -> Right c
let right f = function Right a -> Right (f (a)) | Left c -> Left c

(* Prism: focuses on one constructor of a sum type *)
type ('s, 'a) prism = {
  preview : 's -> 'a option;
  review  : 'a -> 's;
}

let preview prism s = prism.preview s
let review  prism a = prism.review a

(* Transform matching elements *)
let over_prism prism f s =
  match prism.preview s with
  | None   -> s
  | Some a -> prism.review (f a)

type json =
  | JNull
  | JBool   of bool
  | JInt    of int
  | JString of string
  | JArray  of json list

let int_prism : (json, int) prism = {
  preview = (function JInt n -> Some n | _ -> None);
  review  = (fun n -> JInt n);
}

let () =
  let v = JInt 42 in
  Printf.printf "preview int: %s\n" (match preview int_prism v with Some n -> string_of_int n | None -> "none");
  Printf.printf "preview str: %s\n" (match preview int_prism (JString "hi") with Some n -> string_of_int n | None -> "none");

  let doubled = over_prism int_prism (fun n -> n * 2) v in
  Printf.printf "doubled: %s\n" (match preview int_prism doubled with Some n -> string_of_int n | None -> "?");

  Printf.printf "review: %s\n" (match review int_prism 99 with JInt n -> string_of_int n | _ -> "?")

Key Differences

Prism encoding: Choice captures prisms just as Strong captures lenses; the duality (products vs. sums) maps onto profunctor classes.

Function implementation: Functions implement both Strong and Choice — functions can thread both product and sum context; they are simultaneously lenses and prisms (isos) in the profunctor encoding.

Traversal: Traversal corresponds to profunctors that are both Strong and Choice with certain coherence conditions.

Wander: More general traversals require a Wander class beyond Choice; the full hierarchy is Profunctor ⊂ Strong ⊂ Wander.

OCaml Approach

OCaml's Choice profunctor:

module type CHOICE = sig
  include PROFUNCTOR
  val left : ('a, 'b) t -> (('a, 'c) Either.t, ('b, 'c) Either.t) t
  val right : ('a, 'b) t -> (('c, 'a) Either.t, ('c, 'b) Either.t) t
end

A prism type ('s, 't, 'a, 'b) prism = { run : 'p. (module CHOICE with type ('a,'b) t = 'p) -> 'p a b -> 'p s t } requires first-class module polymorphism — OCaml handles this better than Rust.

Full Source

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

(* Choice profunctor: can be applied to one side of a sum type.
   left  :: p a b -> p (a + c) (b + c)
   right :: p a b -> p (c + a) (c + b)
   Enables building prisms! *)

(* Functions form a choice profunctor *)
let left  f = function Left a  -> Left (f a)  | Right c -> Right c
let right f = function Right a -> Right (f (a)) | Left c -> Left c

(* Prism: focuses on one constructor of a sum type *)
type ('s, 'a) prism = {
  preview : 's -> 'a option;
  review  : 'a -> 's;
}

let preview prism s = prism.preview s
let review  prism a = prism.review a

(* Transform matching elements *)
let over_prism prism f s =
  match prism.preview s with
  | None   -> s
  | Some a -> prism.review (f a)

type json =
  | JNull
  | JBool   of bool
  | JInt    of int
  | JString of string
  | JArray  of json list

let int_prism : (json, int) prism = {
  preview = (function JInt n -> Some n | _ -> None);
  review  = (fun n -> JInt n);
}

let () =
  let v = JInt 42 in
  Printf.printf "preview int: %s\n" (match preview int_prism v with Some n -> string_of_int n | None -> "none");
  Printf.printf "preview str: %s\n" (match preview int_prism (JString "hi") with Some n -> string_of_int n | None -> "none");

  let doubled = over_prism int_prism (fun n -> n * 2) v in
  Printf.printf "doubled: %s\n" (match preview int_prism doubled with Some n -> string_of_int n | None -> "?");

  Printf.printf "review: %s\n" (match review int_prism 99 with JInt n -> string_of_int n | _ -> "?")

Deep Comparison

OCaml vs Rust: Choice 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 left for a Kleisli<Option, A, B> profunctor — threading Option context through choice.

Write prism_via_choice(preview, review) creating a prism from the Choice profunctor encoding.

Verify that right(f) = dimap(Either::swap, Either::swap)(left(f)) — right is derivable from left.

Open Source Repos

functional-rust

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

Rust