package liquidsoap-lang

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Types

liquidsoap-lang
- Liquidsoap_lang
  - Active_value
    
    Make
    
    T
    
    T
  - Build_config
  - Builtins_bool
  - Builtins_eval
  - Builtins_getter
  - Builtins_json
    
    JsonSpecs
    
    JsonValue
    
    Term
    
    T
  - Builtins_lang
  - Builtins_list
  - Builtins_math
  - Builtins_null
  - Builtins_profiler
  - Builtins_ref
  - Builtins_regexp
    
    RegExp
    
    Term
    
    T
  - Builtins_string
  - Builtins_yaml
  - Doc
    
    Map
    
    Plug
    
    Protocol
    
    Value
  - Environment
  - Error
  - Evaluation
  - Extralib
    
    Array
    
    Int
    
    List
    
    String
    
    Unix
  - Ground_type
    
    Bool
    
    Custom
    
    Float
    
    Int
    
    Make
    
    _
    
    Never
    
    Spec
    
    String
  - Hooks
  - Json
  - Json_base
  - Json_lexer
  - Json_parser
  - Lang
    
    Ground
    
    Regexp
  - Lang_core
    
    Position
    
    Single_position
    
    Stacktrace
  - Lang_error
    
    Error
    
    Term
    
    T
    
    ErrorDef
  - Lang_regexp
    
    Regexp
  - Lang_string
    
    Version
  - Lexer
    
    String
  - Methods
  - Modules
  - Parser
  - Parser_helper
  - Plug
  - Pos
    
    List
    
    Option
  - Preprocessor
  - Profiler
    
    M
  - Ref_type
  - Regexp
    
    T
  - Repr
  - Runtime
  - Runtime_error
  - Sites
    
    Sites
  - Startup
  - Term
    
    Abstract
    
    AbstractDef
    
    Ground
    
    GroundDef
    
    Methods
    
    MkAbstract
    
    Def
    
    T
    
    MkGround
    
    D
    
    Vars
  - Type
  - Type_base
    
    Constraints
    
    DS
    
    R
    
    Subst
    
    M
    
    Var
    
    Vars
  - Typechecking
  - Typing
  - Unifier
  - Utils
  - Value
    
    Abstract
    
    MkAbstract
    
    Def
    
    Term
    
    T
    
    MkAbstractFromTerm
    
    Term
    
    RuntimeType
    
    Term
    
    T
liquidsoap-lang.console
- Console

Legend:
Library
Module
Module type
Parameter
Class
Class type

val debug : bool Stdlib.ref

Show debugging information.

val debug_levels : bool Stdlib.ref

Show variables levels.

val debug_variance : bool Stdlib.ref

Types

type variance = [

| `Covariant
| `Invariant

]

type descr = ..

Type description

type t = {

pos : Pos.Option.t;
descr : descr;

}

A type

type constr_t = ..

Constraint type

type constr_t +=

| Num
| Ord

type constr = {

t : constr_t;
constr_descr : string;
univ_descr : string option;
satisfied : subtype:(t -> t -> unit) -> satisfies:(t -> unit) -> t -> unit;

}

module Constraints : sig ... end

type constructed = {

constructor : string;
params : (variance * t) list;

}

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

type var = {

name : int;
mutable level : int;
mutable constraints : Constraints.t;

}

Contents of a variable.

type invar =

| Free of var
(*
the variable is free
*)
| Link of variance * t
(*
the variable has bee substituted
*)

type scheme = var list * t

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

type meth = {

meth : string;
(*
name of the method
*)
optional : bool;
(*
is the method optional?
*)
scheme : scheme;
(*
type scheme
*)
doc : string;
(*
documentation
*)
json_name : string option;
(*
name when represented as JSON
*)

}

A method.

type repr_t = {

t : t;
json_repr : [ `Tuple | `Object ];

}

module DS : sig ... end

Sets of type descriptions.

val string_of_constr : constr -> string

module Subst : sig ... end

Substitutions.

module R : sig ... end

type custom = ..

type custom_handler = {

typ : custom;
copy_with : (t -> t) -> custom -> custom;
occur_check : (t -> unit) -> custom -> unit;
filter_vars : (var list -> t -> var list) -> var list -> custom -> var list;
repr : (var list -> t -> R.t) -> var list -> custom -> R.t;
subtype : (t -> t -> unit) -> custom -> custom -> unit;
sup : (t -> t -> t) -> custom -> custom -> custom;
to_string : custom -> string;

}

type descr +=

| Custom of custom_handler
| Constr of constructed
| Getter of t
(*
a getter: something that is either a t or () -> t
*)
| List of repr_t
| Tuple of t list
| Nullable of t
(*
something that is either t or null
*)
| Meth of meth * t
(*
t with a method added
*)
| Arrow of (bool * string * t) list * t
(*
a function
*)
| Var of invar Stdlib.ref
(*
a type variable
*)

exception NotImplemented

exception Exists of Pos.Option.t * string

exception Unsatisfied_constraint

val unit : descr

module Var : sig ... end

Operations on variables.

module Vars : sig ... end

Sets of variables.

val make : ?pos:(Stdlib.Lexing.position * Stdlib.Lexing.position) -> descr -> t

Create a type from its value.

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.

val demeth : t -> t

Remove methods. This function also removes links.

val deep_demeth : t -> t

val filter_meths : t -> (meth -> bool) -> 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:(Stdlib.Lexing.position * Stdlib.Lexing.position) ->
  ?json_name:string ->
  ?optional:bool ->
  string ->
  scheme ->
  ?doc:string ->
  t ->
  t

Add a method to a type.

val meths : 
  ?pos:(Stdlib.Lexing.position * Stdlib.Lexing.position) ->
  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 : 
  ?constraints:Constraints.elt list ->
  ?level:int ->
  ?pos:(Stdlib.Lexing.position * Stdlib.Lexing.position) ->
  unit ->
  t

Create a fresh variable.

val to_string_fun : (?generalized:var list -> t -> string) Stdlib.ref

val to_string : ?generalized:var list -> t -> string

String representation of a type.

val string_of_scheme : (var list * t) -> string

val is_fun : t -> bool

val is_source : t -> bool

val custom_types : (string, unit -> t) Stdlib.Hashtbl.t

val register_type : string -> (unit -> t) -> unit

val find_type_opt : string -> (unit -> t) option

val mk_invariant : t -> unit