OCaml 教程 / OCaml 签名与抽象类型
OCaml 签名与抽象类型
签名（signature）定义了模块的接口契约，是 OCaml 模块系统实现信息隐藏和抽象的核心机制。本文系统讲解签名定义、抽象类型暴露策略和设计原则。
module type 签名定义
签名用 module type ... = sig ... end 定义，描述模块必须暴露哪些类型和值。
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 is_empty : 'a t -> bool
val size : 'a t -> int
end
签名中的元素类型
| 元素 | 语法 | 用途 |
|---|---|---|
val | val x : int | 声明一个值 |
type | type t | 声明一个抽象类型 |
type t = int | 具体类型别名 | 暴露类型定义 |
exception | exception E of string | 声明异常 |
module | module M : SIG | 声明子模块 |
include | include SIG | 包含另一个签名 |
module type COMPARABLE = sig
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val to_string : t -> string
end
module type PRINTABLE = sig
type t
val to_string : t -> string
val print : t -> unit
end
抽象类型 type t
当签名中只写 type t（没有 = ...）时，类型对外部是抽象的——外部不知道其内部结构。
module type COUNTER = sig
type t (* 抽象类型：外部无法构造或解构 *)
val create : unit -> t
val increment : t -> t
val get : t -> int
end
module Counter : COUNTER = struct
type t = int (* 内部实现是 int *)
let create () = 0
let increment c = c + 1
let get c = c
end
let () =
let c = Counter.create () in
let c = Counter.increment c in
let c = Counter.increment c in
Printf.printf "Count: %d\n" (Counter.get c)
(* 以下代码会编译失败： *)
(* let _ = Counter.create () + 1 *) (* 类型抽象保护 *)
⚠️ 注意：抽象类型是双刃剑。如果外部完全无法构造，可能限制实用性。需要通过构造函数和访问器函数提供操作入口。
具体类型暴露
有时我们希望类型对外可见，允许外部直接操作。
module type POINT_2D = sig
type t = { x : float; y : float } (* 具体类型，记录字段可见 *)
val origin : t
val distance : t -> t -> float
val translate : float -> float -> t -> t
end
module Point : POINT_2D = struct
type t = { x : float; y : float }
let origin = { x = 0.0; y = 0.0 }
let distance a b =
let dx = a.x -. b.x in
let dy = a.y -. b.y in
sqrt (dx *. dx +. dy *. dy)
let translate dx dy p =
{ x = p.x +. dx; y = p.y +. dy }
end
let () =
let p1 = Point.origin in
let p2 = Point.translate 3.0 4.0 p1 in
Printf.printf "Distance: %f\n" (Point.distance p1 p2)
💡 提示：具体类型暴露让调用方代码更简洁，但牺牲了封装性。如果将来改变内部结构，所有使用该类型的代码都要修改。
部分暴露：只暴露部分接口
通过签名约束，可以精确控制模块暴露的内容。
module type READONLY_SET = sig
type 'a t
val empty : 'a t
val mem : 'a -> 'a t -> bool (* 可见 *)
val cardinal : 'a t -> int (* 可见 *)
val to_list : 'a t -> 'a list (* 可见 *)
(* add, remove 等函数不暴露 *)
end
module ReadonlySet : READONLY_SET = struct
module S = Set.Make(Stdlib)
type 'a t = 'a S.t
let empty = S.empty
let mem = S.mem
let cardinal = S.cardinal
let to_list s = S.fold (fun x acc -> x :: acc) s []
end
签名中的 type constraint
module type HASHABLE = sig
type t
val hash : t -> int
val equal : t -> t -> bool
end
module type COLLECTION = sig
type elem (* 元素类型抽象 *)
type t (* 集合类型抽象 *)
val empty : t
val add : elem -> t -> t
val mem : elem -> t -> bool
end
堆栈模块完整实例
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 is_empty : 'a t -> bool
val size : 'a t -> int
val to_list : 'a t -> 'a list
end
module ListStack : STACK = struct
type 'a t = 'a list
let empty = []
let push x xs = x :: xs
let pop = function
| [] -> None
| x :: xs -> Some (x, xs)
let peek = function
| [] -> None
| x :: _ -> Some x
let is_empty = function
| [] -> true
| _ -> false
let length = List.length
let size = length
let to_list s = s
end
(* 用数组实现的堆栈，同样满足 STACK 签名 *)
module ArrayStack : STACK = struct
type 'a t = {
mutable data : 'a array;
mutable len : int;
}
let empty = { data = [||]; len = 0 }
let push x s =
let new_len = s.len + 1 in
let new_data = Array.make new_len x in
Array.blit s.data 0 new_data 0 s.len;
{ data = new_data; len = new_len }
let pop s =
if s.len = 0 then None
else begin
let x = s.data.(s.len - 1) in
s.len <- s.len - 1;
Some (x, s)
end
let peek s =
if s.len = 0 then None
else Some s.data.(s.len - 1)
let is_empty s = s.len = 0
let size s = s.len
let to_list s = Array.to_list (Array.sub s.data 0 s.len)
end
💡 提示：同一签名（
STACK）可以有多种实现（ListStack、ArrayStack）。这是面向接口编程在 OCaml 中的体现。调用方只依赖签名，可以自由切换实现。
签名中的模块约束
module type MONAD = sig
type 'a t
val return : 'a -> 'a t
val bind : 'a t -> ('a -> 'b t) -> 'b t
end
module type MONAD_WITH_MAP = sig
include MONAD
val map : ('a -> 'b) -> 'a t -> 'b t
end
(* 从 bind 推导 map 的默认实现 *)
module MonadOps (M : MONAD) : MONAD_WITH_MAP with type 'a t = 'a M.t = struct
include M
let map f m = M.bind m (fun x -> M.return (f x))
end
信息隐藏设计原则
| 原则 | 说明 | 示例 |
|---|---|---|
| 最小暴露 | 只暴露必要的接口 | 抽象 type t |
| 不变式保护 | 通过抽象类型保证内部约束 | 平衡树的平衡因子 |
| 实现自由 | 内部实现可独立更换 | ListStack → ArrayStack |
| 类型安全 | 编译期防止非法操作 | 无法直接操作内部结构 |
实际业务场景：银行账户
module type ACCOUNT = sig
type t
val create : string -> float -> t
val deposit : float -> t -> t
val withdraw : float -> t -> t option (* 余额不足返回 None *)
val balance : t -> float
val owner : t -> string
end
module Account : ACCOUNT = struct
type t = {
owner : string;
balance : float;
}
let create name initial =
{ owner = name; balance = max 0.0 initial }
let deposit amount a =
{ a with balance = a.balance +. amount }
let withdraw amount a =
if amount > a.balance then None
else Some { a with balance = a.balance -. amount }
let balance a = a.balance
let owner a = a.owner
end
let () =
let acc = Account.create "Alice" 1000.0 in
let acc = Account.deposit 500.0 acc in
match Account.withdraw 2000.0 acc with
| None -> Printf.printf "Insufficient funds. Balance: %f\n"
(Account.balance acc)
| Some acc -> Printf.printf "New balance: %f\n"
(Account.balance acc)
⚠️ 注意：由于
t是抽象的，外部无法伪造账户、直接修改余额或篡改所有者名称。所有操作必须通过ACCOUNT签名中定义的函数进行，保证了业务规则的强制执行。