Module Frama_c_kernel.Type

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 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.

type 'a ty = 'a t

Pretty printing materials

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 register.

val register : ?closure:bool -> name:string -> 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).

  • raises AlreadyExists

    if the given name is already used by another type.

  • raises Invalid_argument

    if reprs is the empty list

exception No_abstract_type of string
module Abstract (_ : sig ... end) : sig ... end

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 (Datatype.list Datatype.int)) returns "unit -> int list"; "unit"; "int list"; "int" .

  • since Oxygen-20120901
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 (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 Polymorphic_input: very same functions with one additional argument corresponding to the second type variable.

module type Polymorphic2 = sig ... end

Same as Polymorphic for polymorphic types with two type variables.

module Polymorphic2 (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 Polymorphic2 for functions: same signature than Polymorphic2 with possibility to specify a label for the function parameter.

module type Polymorphic3_input = sig ... end

See module Polymorphic_input: very same functions with two additional arguments corresponding to the second and third type variables.

module type Polymorphic3 = sig ... end

Same as Polymorphic for polymorphic types with three type variables.

module Polymorphic3 (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 Polymorphic_input: very same functions with three additional arguments corresponding to the additional type variables.

module type Polymorphic4 = sig ... end

Same as Polymorphic for polymorphic types with four type variables.

module Polymorphic4 (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 (Key : sig ... end) (Info : sig ... end) : Heterogeneous_table with type key = Key.t and type 'a info = 'a Info.t

Build an heterogeneous table associating keys to info. Not efficient for types registered without ml name.

module String_tbl (Info : sig ... end) : Heterogeneous_table with type key = string and type 'a info = 'a Info.t

Heterogeneous tables indexed by string.

module Ty_tbl (Info : sig ... end) : sig ... end

Heterogeneous tables indexed by type value. Roughly the same signature that Hashtbl.S.

module Obj_tbl : sig ... end

Heterogeneous table for the keys, but polymorphic for the values.