Module Liquidsoap_lang_types.Type_base

The raw representation behind Type, for the few places that need to build or traverse it directly.

val debug : bool Stdlib.ref

Show debugging information.

val debug_levels : bool Stdlib.ref

Show variables levels.

val debug_variance : bool Stdlib.ref

Type information comes attached to the AST from the parsing, with appropriate sharing of the type variables. Then the type inference performs in-place unification.

In order to report precise type error messages, we put very dense parsing location information in the type. Every layer of it can have a location. Destructive unification introduces links in such a way that the old location is still accessible.

The level annotation represents the number of abstractions which surround the type in the AST -- function arguments and let-in definitions. It is used to safely generalize types.

Finally, constraints can be attached to existential (unknown, '_a) and universal ('a) type variables.

Types

Type description

type variance = [
  1. | `Covariant
  2. | `Invariant
]
type 'a argument = bool * string * 'a
module R : sig ... end
type custom
type meth_doc = {
  1. meth_descr : string;
  2. category : [ `Method | `Callback | `Composition ];
}
and constr = {
  1. constr_name : string;
    (*

    What a dump names it by, wherever it is read.

    *)
  2. constr_descr : string;
  3. univ_descr : string option;
  4. satisfied : subtype:(t -> t -> unit) -> satisfies:(t -> unit) -> t -> unit;
}
and constructed = {
  1. constructor : string;
  2. params : (variance * t) list;
}

A type constructor applied to arguments (e.g. source).

and var = {
  1. name : int;
  2. mutable level : int;
  3. mutable constraints : constr Liquidsoap_lang_types__.Type_constraints.t;
}

Contents of a variable.

and invar =
  1. | Free of var
    (*

    the variable is free

    *)
and scheme = var list * t

A type scheme (i.e. a type with universally quantified variables).

and meth = {
  1. meth : string;
    (*

    name of the method

    *)
  2. optional : bool;
    (*

    is the method optional?

    *)
  3. scheme : scheme;
    (*

    type scheme

    *)
  4. doc : meth_doc;
    (*

    documentation

    *)
  5. json_name : string option;
    (*

    name when represented as JSON

    *)
}

A method.

and repr_t = {
  1. t : t;
  2. json_repr : [ `Tuple | `Object ];
}
and custom_handler = {
  1. typ : custom;
  2. serialize : custom -> string;
  3. copy_with : (t -> t) -> custom -> custom;
  4. occur_check : (t -> unit) -> custom -> unit;
  5. filter_vars : (var list -> t -> var list) -> var list -> custom -> var list;
  6. repr : (var list -> t -> constr R.t) -> var list -> custom -> constr R.t;
  7. subtype : (t -> t -> unit) -> custom -> custom -> unit;
  8. sup : (t -> t -> t) -> custom -> custom -> custom;
}

What a custom type carries, and what can be done with it. None of it can be written out: the payload is the process's own, the rest are closures, which is what serialize is for.

and custom_handler_state =
  1. | Resolved of custom_handler
  2. | Dumped of {
    1. payload_id : int;
    2. payload : string;
    3. types : t list;
    }

A custom type read back from a dump arrives Dumped: its payload's serialized form, the types that payload holds, and which payload it was, since types that shared one on the way out have to share one again.

and custom_instance = {
  1. custom_name : string;
  2. mutable handler_state : custom_handler_state;
}
and var_t = {
  1. id : int;
  2. mutable contents : invar;
}
and descr =
  1. | String
  2. | Int
  3. | Float
  4. | Bool
  5. | Never
  6. | Custom of custom_instance
  7. | Constr of constructed
  8. | Getter of t
    (*

    a getter: something that is either a t or () -> t

    *)
  9. | List of repr_t
  10. | Tuple of t list
  11. | Nullable of t
    (*

    something that is either t or null

    *)
  12. | Meth of meth * t
    (*

    t with a method added

    *)
  13. | Arrow of t argument list * t
    (*

    a function

    *)
  14. | Var of var_t
    (*

    a type variable

    *)
module Constraints : sig ... end
module DS : sig ... end
val registered_constraints : (string, constr) Stdlib.Hashtbl.t
val constr : ?univ_descr:??? -> name:string -> descr:string -> (subtype:(t -> t -> unit) -> satisfies:(t -> unit) -> t -> unit) -> constr
val registered_constraint : string -> constr option
val string_of_constr : constr -> string
exception Unsatisfied_constraint
val unit : descr
module Var : sig ... end

Operations on variables.

module Vars : sig ... end

Sets of variables.

val custom_handler : custom_instance -> custom_handler
val var_id_atom : int Stdlib.Atomic.t
val var_id : unit -> int
val deref : t -> t

Dereferencing gives you the meaning of a term, going through links created by instantiations. One should (almost) never work on a non-dereferenced type.

Create a type from its value.

val demeth : t -> t

Remove methods. This function also removes links.

val filter_meths : t -> (meth -> bool) -> t
val map_meths : t -> (meth -> meth) -> t
val remeth : t -> t -> t

Put the methods of the first type around the second type.

val invoke : t -> string -> scheme

Type of a method in a type.

val has_meth : t -> string -> bool

Do we have a method with given label?

val invokes : t -> string list -> var list * t

Type of a submethod in a type.

val meth : ?pos:Liquidsoap_lang_prelude.Pos.Option.base -> ?json_name:??? -> ?category:??? -> ?optional:??? -> string -> scheme -> ?doc:??? -> t -> t

Add a method to a type.

val meths : ?invoke:??? -> ?pos:Liquidsoap_lang_prelude.Pos.Option.base -> string list -> scheme -> t -> t

Add a submethod to a type.

val split_meths : t -> meth list * t

Split the methods from the type.

val var_name_atom : int Stdlib.Atomic.t

Create a fresh variable.

val var_name : unit -> int
val var : ?constraints:??? -> ?level:??? -> ?pos:Liquidsoap_lang_prelude.Pos.Option.base -> unit -> t
module Fresh : sig ... end
val fresh : t -> t
val is_fun : t -> bool
val is_source : t -> bool
val custom_types : (string, unit -> t) Stdlib.Hashtbl.t
val register_single_type : string -> (unit -> t) -> unit
val register_type : string -> (unit -> t) -> unit

Register a type under a possibly dotted name, creating the intermediate method types as needed.

val find_opt_typ : string -> (unit -> t) option
val mk_invariant : t -> unit
val hide_meth : string -> t -> t
val opt_meth : string -> t -> t
val get_meth : string -> t -> meth