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

type precedence =
  1. | Basic
    (*

    Normal precedence

    *)
  2. | Call
    (*

    Instantiation of polymorphic type

    *)
  3. | Tuple
  4. | List
  5. | NoPar

Precedences used for generating the minimal number of parenthesis in combination with function 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.

  • since Carbon-20101201

Constructor and getters

exception AlreadyExists of string

May be raised by 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.

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