module Type:Type value. A type value is a value representing a static ML monomorphic type. This API is quite low level. Prefer to use modulesig
..end
Datatype
instead
whenever possible.val no_obj : unit -> unit
type 'a
t
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.type'a
ty ='a t
type
precedence =
| |
Basic |
| |
Call |
| |
Tuple |
| |
List |
| |
NoPar |
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
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
Type.register
.val register : ?closure:bool ->
?dynamic_abstract:bool ->
name:string ->
ml_name:string option -> Structural_descr.t -> 'a list -> 'a t
register ?closure ?dynamic_abstract ~name ~ml_name descr reprs
registers
a new type value. Should not be used directly. Use one of functors of
module Datatype
instead.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.type
abstract
val get : string -> abstract t
val name : 'a t -> string
val structural_descr : 'a t -> Structural_descr.t
val reprs : 'a t -> 'a list
val digest : 'a t -> Digest.t
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 is_dynamic_abstract : 'a t -> 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
module Polymorphic:
module type Polymorphic2_input =sig
..end
Type.Polymorphic_input
: very same functions with one additional
argument corresponding to the second type variable.
module type Polymorphic2 =sig
..end
Type.Polymorphic
for polymorphic types with two type variables.
module Polymorphic2:
module Function:sig
..end
Type.Polymorphic2
for functions: same signature than
Type.Polymorphic2
with possibility to specify a label for the function
parameter.
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
) ->
module String_tbl:
module Ty_tbl:
module Obj_tbl:sig
..end