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.
type 'a
t
Type of type values. For each monomorphic type ty
, a value of type ty
dynamically represents the type
tty
. Such a value is called a type
value and should be unique for each static monomorphic type.
type'a
ty ='a t
type
precedence =
| |
Basic |
| |
Call |
| |
Tuple |
| |
List |
| |
NoPar |
Precedences used for generating the minimal number of parenthesis in
combination with function Type.par
below.
val par : precedence ->
precedence ->
Stdlib.Format.formatter -> (Stdlib.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
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
.
exception AlreadyExists of string
May be raised by Type.register
.
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.
AlreadyExists
if the given name is already used by another type.Invalid_argument
if reprs
is the empty listvalue_name
is now ml_name
. Must provide a
structural descriptor. Argument pp
does not exist anymore.exception No_abstract_type of string
module Abstract:
Apply this functor to access to the abstract type of the given name.
val name : 'a t -> string
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 -> Stdlib.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
returns
(Datatype.list Datatype.int)) "unit -> int list"; "unit"; "int
.
list"; "int"
val ml_name : 'a t -> string
val pp_ml_name : 'a t -> precedence -> Stdlib.Format.formatter -> unit
val set_ml_name : 'a t -> string option -> unit
val set_name : 'a t -> string -> unit
val equal : 'a t -> 'b t -> bool
val compare : 'a t -> 'b t -> int
val hash : 'a t -> int
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:
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:
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:
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.
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
tend
) ->
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
tend
) ->
Heterogeneous_table
with type key = string and type 'a info = 'a Info.t
Heterogeneous tables indexed by string.
module Ty_tbl:
Heterogeneous tables indexed by type value.
module Obj_tbl:sig
..end
Heterogeneous table for the keys, but polymorphic for the values.