Модуль 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 — это Some Equal, если идентификатор i0 равен i1, и None в противном случае.

Пример

Ниже показано, как использовать идентификаторы типов для реализации простого разнородного словаря ключей-значений. В отличие от Map, где ключи отображаются на значения одного и того же гомогенного типа, этот словарь может сопоставлять различные типы значений каждому ключу.

(** Разнородные словари. *)


module Dict : sig
type t

(** Тип для словарей. *)


type 'a key

(** Тип для ключей, связывающих значения типа 'a. *)


val key : unit -> 'a key

(** key () — это новый ключ словаря. *)


val empty : t

(** empty — это пустой словарь. *)


val add : 'a key -> 'a -> t -> t

(** add k v d — это d со связанным k и v. *)


val remove : 'a key -> t -> t

(** remove k d — это d со удалённой последней связью k. *)


val find : 'a key -> t -> 'a option

(** find k d — это связь k в d, если такая есть. *)


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