Previous  Up  Next

Module Type

module Type: sig .. end
Type value. A type value is a value representing a static ML monomorphic type. This API is quite low level. Prefer to use module Datatype instead whenever possible.
Consult the Plugin Development Guide for additional details.

Type declaration


type 'a t
Type of type values. For each monomorphic type ty, a value of type ty t dynamically represents the type ty. Such a value is called a type value and should be unique for each static monomorphic type.
Consult the Plugin Development Guide for additional details.
type 'a ty = 'a t

Pretty printing materials


type precedence =
| Basic (*
Consult the Plugin Development Guide for additional details.
*)
| Call (*
Consult the Plugin Development Guide for additional details.
*)
| Tuple
| List
| NoPar
Precedences used for generating the minimal number of parenthesis in combination with function Type.par below.
val par : precedence ->
       precedence -> Format.formatter -> (Format.formatter -> unit) -> unit
par context myself fmt pp puts parenthesis around the verbatim prints by pp according to the precedence myself of the verbatim and to the precedence context of the caller of the pretty printer. fmt is the output formatter.

The typical use is the following: let pretty_print p_caller fmt x = let pp fmt = Format.fprintf "..." ... x ... in let myself = Call in par p_caller myself fmt pp
Consult the Plugin Development Guide for additional details.

val par_ty_name : ('a t -> bool) -> 'a t -> string
par_ty_name f ty puts parenthesis around the name of the ty iff f ty is true.
Since Carbon-20101201

Constructor and getters


exception AlreadyExists of string
May be raised by Type.register.
Consult the Plugin Development Guide for additional details.
val register : ?closure:bool ->
       name:string ->
       ml_name:string option -> Structural_descr.t -> 'a list -> 'a t
register ?closure ~name ~ml_name descr reprs registers a new type value. Should not be used directly. Use one of functors of module Datatype instead. closure is true iff the type is a function type. name is the name of the type. Must be a valid OCaml type name (eventually prefixed by a module path). ml_name is the OCaml name of the registered type value.
Raises Change in Boron-20100401: request a list of representant, not only a single one
Change in Carbon-20101201: value_name is now ml_name. Must provide a structural descriptor. Argument pp does not exist anymore.
exception No_abstract_type of string
module Abstract: 
functor (T : sig


val name : string
end) -> sig .. end
Apply this functor to access to the abstract type of the given name. 
val name : 'a t -> string
Consult the Plugin Development Guide for additional details.
val structural_descr : 'a t -> Structural_descr.t
val reprs : 'a t -> 'a list
Not usable in the "no-obj" mode
val digest : 'a t -> Digest.t
val get_embedded_type_names : 'a t -> string list
Get the list of names containing in the type represented by the given type value. For instance get_embedded_type_names (Datatype.func Datatype.unit (Datatype.list Datatype.int)) returns "unit -> int list"; "unit"; "int list"; "int" .
Since Oxygen-20120901
val ml_name : 'a t -> string
val pp_ml_name : 'a t -> precedence -> Format.formatter -> unit
val set_ml_name : 'a t -> string option -> unit
val set_name : 'a t -> string -> unit
Since Neon-20140301

Type values are comparable


val equal : 'a t -> 'b t -> bool
val compare : 'a t -> 'b t -> int
val hash : 'a t -> int

Polymorphic type values

Functors for handling polymorphic type: one type value must be registered for each monomorphic instance of a polymorphic type.

module type Polymorphic_input = sig .. end
module type Polymorphic = sig .. end
For a polymorphic type value with one type variable, you must use an implementation of this signature. 
module Polymorphic: 
functor (T : Polymorphic_input) -> Polymorphic  with type 'a poly = 'a T.t
Generic implementation of polymorphic type value. 
module type Polymorphic2_input = sig .. end
See module Type.Polymorphic_input: very same functions with one additional argument corresponding to the second type variable. 
module type Polymorphic2 = sig .. end
Same as Type.Polymorphic for polymorphic types with two type variables. 
module Polymorphic2: 
functor (T : Polymorphic2_input) -> Polymorphic2  with type ('a, 'b) poly = ('a, 'b) T.t
Generic implementation of polymorphic type value with two type variables. 
module Function: sig .. end
Instance of Type.Polymorphic2 for functions: same signature than Type.Polymorphic2 with possibility to specify a label for the function parameter. 
module type Polymorphic3_input = sig .. end
See module Type.Polymorphic_input: very same functions with two additional arguments corresponding to the second and third type variables. 
module type Polymorphic3 = sig .. end
Same as Type.Polymorphic for polymorphic types with three type variables. 
module Polymorphic3: 
functor (T : Polymorphic3_input) -> Polymorphic3  with type ('a, 'b, 'c) poly = ('a, 'b, 'c) T.t
Generic implementation of polymorphic type value with three type variables. 
module type Polymorphic4_input = sig .. end
See module Type.Polymorphic_input: very same functions with three additional arguments corresponding to the additional type variables. 
module type Polymorphic4 = sig .. end
Same as Type.Polymorphic for polymorphic types with four type variables. 
module Polymorphic4: 
functor (T : Polymorphic4_input) -> Polymorphic4  with type ('a, 'b, 'c, 'd) poly = ('a, 'b, 'c, 'd) T.t
Generic implementation of polymorphic type value with four type variables.

Heterogeneous Tables

These tables are safe to use but nevertheless not for casual users.

module type Heterogeneous_table = sig .. end
module Make_tbl: 
functor (Key : sig
include Hashtbl.HashedType



val to_string : Type.t -> string
end) -> 
functor (Info : sig


type 'a t 



end) -> Heterogeneous_table  with type key = Key.t and type 'a info = 'a Info.t
Build an heterogeneous table associating keys to info. 
module String_tbl: 
functor (Info : sig


type 'a t 



end) -> Heterogeneous_table  with type key = string and type 'a info = 'a Info.t
Heterogeneous tables indexed by string. 
module Ty_tbl: 
functor (Info : sig


type 'a t 



end) -> sig .. end
Heterogeneous tables indexed by type value. 
module Obj_tbl: sig .. end
Heterogeneous table for the keys, but polymorphic for the values.

Internal API


val no_obj : unit -> unit
Deactivate all the black magic. Roughly, in this mode, nothing is done by this module.
val may_use_obj : unit -> bool
Internal use only. Please, do not use it yourself.
val add_abstract_types : (string -> string -> unit) Pervasives.ref
val sfprintf : ('a, Format.formatter, unit, string) Pervasives.format4 -> 'a
similar as Format.sprintf, but %a are allowed in the formatting string