146 Advanced

Opaque Types

Functional Programming

Tutorial Video

Text description (accessibility)

This video demonstrates the "Opaque Types" functional Rust example. Difficulty level: Advanced. Key concepts covered: Functional Programming. Information hiding is a foundational software engineering principle: expose what a module does, not how it does it. Key difference from OCaml: 1. **Granularity**: OCaml's opacity is at the module level via signatures; Rust supports both module

Tutorial

The Problem

Information hiding is a foundational software engineering principle: expose what a module does, not how it does it. Opaque types make a concrete type invisible outside its defining module — callers can use the type but cannot inspect its internals, pattern match on it, or construct it directly. This enforces abstraction boundaries, enables safe evolution of internals, and prevents invariant violations from outside the module.

🎯 Learning Outcomes

• Understand opaque types as a module-level abstraction mechanism

• Learn how Rust's pub struct with private fields achieves opacity

• See how impl Trait in return position creates function-level opaque types

• Compare with OCaml's module type signatures as the standard opacity mechanism

Code Example

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

(* Opaque types: the type's representation is hidden by the module signature.
   Callers can only use the type through the provided interface. *)

module type STACK = sig
  type 'a t
  val empty  : 'a t
  val push   : 'a -> 'a t -> 'a t
  val pop    : 'a t -> ('a * 'a t) option
  val peek   : 'a t -> 'a option
  val size   : 'a t -> int
  val is_empty : 'a t -> bool
end

(* List-based implementation — type is opaque outside this module *)
module Stack : STACK = struct
  type 'a t = 'a list
  let empty       = []
  let push x s    = x :: s
  let pop = function
    | []    -> None
    | x :: xs -> Some (x, xs)
  let peek = function
    | []    -> None
    | x :: _ -> Some x
  let size        = List.length
  let is_empty    = (= [])
end

let () =
  let s = Stack.(push 3 (push 2 (push 1 empty))) in
  Printf.printf "size: %d\n"    (Stack.size s);
  Printf.printf "peek: %d\n"    (Option.get (Stack.peek s));
  (match Stack.pop s with
   | Some (top, rest) ->
     Printf.printf "popped: %d, new size: %d\n" top (Stack.size rest)
   | None -> assert false);
  Printf.printf "empty: %b\n"   (Stack.is_empty Stack.empty)

Key Differences

Granularity: OCaml's opacity is at the module level via signatures; Rust supports both module-level (private fields) and function-level (impl Trait) opacity.

Pattern matching: OCaml's opaque types cannot be pattern matched by callers; Rust's structs with private fields similarly prevent construction and field access.

Multiple opaque types: OCaml modules can expose several opaque types in one signature; Rust modules expose one opaque type per struct definition.

Dynamic opacity: Rust's Box<dyn Trait> erases the concrete type dynamically; OCaml achieves this with first-class modules or GADTs.

OCaml Approach

OCaml's module system is the primary mechanism for opacity. A module with signature sig type t val create : unit -> t val use : t -> unit end hides the definition of t from callers. The implementation can be struct type t = int ... end — the int is invisible outside the module. This is the standard way OCaml libraries expose abstract types: Buffer.t, Hashtbl.t, Printf.formatter are all opaque types.

Full Source

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

(* Opaque types: the type's representation is hidden by the module signature.
   Callers can only use the type through the provided interface. *)

module type STACK = sig
  type 'a t
  val empty  : 'a t
  val push   : 'a -> 'a t -> 'a t
  val pop    : 'a t -> ('a * 'a t) option
  val peek   : 'a t -> 'a option
  val size   : 'a t -> int
  val is_empty : 'a t -> bool
end

(* List-based implementation — type is opaque outside this module *)
module Stack : STACK = struct
  type 'a t = 'a list
  let empty       = []
  let push x s    = x :: s
  let pop = function
    | []    -> None
    | x :: xs -> Some (x, xs)
  let peek = function
    | []    -> None
    | x :: _ -> Some x
  let size        = List.length
  let is_empty    = (= [])
end

let () =
  let s = Stack.(push 3 (push 2 (push 1 empty))) in
  Printf.printf "size: %d\n"    (Stack.size s);
  Printf.printf "peek: %d\n"    (Option.get (Stack.peek s));
  (match Stack.pop s with
   | Some (top, rest) ->
     Printf.printf "popped: %d, new size: %d\n" top (Stack.size rest)
   | None -> assert false);
  Printf.printf "empty: %b\n"   (Stack.is_empty Stack.empty)

Deep Comparison

OCaml vs Rust: Opaque Types

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

Create a Token opaque type (private u64 field) with a factory function Token::new() and an is_valid method — verify it cannot be constructed from outside the module.

Implement a session handle: fn open_session() -> impl Session where Session is a trait with read, write, and close methods.

Design an opaque Config type that loads from a file and exposes a get(key: &str) -> Option<&str> method, hiding all implementation details.

Open Source Repos

functional-rust

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

Rust