模块 Type.Id

module Id: sig .. end

类型标识符。

类型标识符是一个表示类型的值。给定两个类型标识符，可以测试它们的相等性来证明它们表示相同的类型。请注意

不相等的标识符并不意味着类型不相等：一个给定的类型可以由多个标识符表示。
类型标识符可以被编组，但它们在解组时会获得一个新的、不同的标识，因此相等性会丢失。

请参阅示例以了解如何使用。

类型标识符

type !'a t

类型 'a 的标识符类型。

val make : unit -> 'a t

make () 是一个新的类型标识符。

val uid : 'a t -> int

uid id 是 id 的运行时唯一标识符。

val provably_equal : 'a t -> 'b t -> ('a, 'b) Type.eq option

provably_equal i0 i1 如果标识符 i0 等于 i1 则为 Some Equal，否则为 None。

示例

以下显示了如何使用类型标识符来实现一个简单的异构键值字典。与 Map 的键映射到单一、同构类型的值不同，这个字典可以将不同类型的值与每个键关联。

 (** Heterogeneous dictionaries. *)

module Dict : sig
  type t
     (** The type for dictionaries. *)


  type 'a key
     (** The type for keys binding values of type 'a. *)


  val key : unit -> 'a key
     (** key () is a new dictionary key. *)


  val empty : t
     (** empty is the empty dictionary. *)


  val add : 'a key -> 'a -> t -> t
     (** add k v d is d with k bound to v. *)


  val remove : 'a key -> t -> t
     (** remove k d is d with the last binding of k removed. *)


  val find : 'a key -> t -> 'a option
     (** find k d is the binding of k in d, if any. *)

end = struct
  type 'a key = 'a Type.Id.t
  type binding = B : 'a key * 'a -> binding
  type t = (int * binding) list

  let key () = Type.Id.make ()
  let empty = []
  let add k v d = (Type.Id.uid k, B (k, v)) :: d
  let remove k d = List.remove_assoc (Type.Id.uid k) d
  let find : type a. a key -> t -> a option = fun k d ->
    match List.assoc_opt (Type.Id.uid k) d with
    | None -> None
    | Some (B (k', v)) ->
        match Type.Id.provably_equal k k' with
        | Some Type.Equal -> Some v
        | None -> assert false
end