package liquidsoap-lang

You can search for identifiers within the package.

in-package search v0.2.0

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

User-friendly representation of types.

val show_record_schemes : bool ref

Show generalized variables in records.

val global_evar_names : bool ref

Use globally unique names for existential variables.

include module type of struct include Type_base.R end

type meth = Type_base.R.meth = {

name : string;
optional : bool;
scheme : var list * t;
json_name : string option;

}

and t = [

| `Constr of string * (Type_base.variance * t) list
| `List of t * [ `Object | `Tuple ]
| `Tuple of t list
| `Nullable of t
| `Meth of meth * t
| `Arrow of (bool * string * t) list * t
| `Getter of t
| `EVar of var
| `UVar of var
| `Ellipsis
| `Range_Ellipsis
| `Debug of string * t * string

]

and var = string * Type_base.Constraints.t

val excerpt : (Lexing.position * Lexing.position) -> string option

Given a position, find the relevant excerpt.

val excerpt_opt : (Lexing.position * Lexing.position) option -> string option

val name : int -> string

Given a strictly positive integer, generate a name in a-z+: a, b, ... z, aa, ab, ... az, ba, ...

val evar_global_name : int -> string

Generate a globally unique name for evars (used for debugging only).

val make : 
  ?filter_out:(Type_base.t -> bool) ->
  ?generalized:Type_base.var list ->
  Type_base.t ->
  t

Compute the structure that a term represents, given the list of universally quantified variables. Also takes care of computing the printing name of variables, including constraint symbols, which are removed from constraint lists. It supports a mechanism for filtering out parts of the type, which are then translated as `Ellipsis.

val print : Format.formatter -> Type_base.R.t -> unit

Print a type representation. Unless in debug mode, variable identifiers are not shown, and variable names are generated. Names are only meaningful over one printing, as they are re-used.

val to_string : Type_base.R.t -> string

val print_type : Format.formatter -> Type_base.t -> unit

val print_scheme : 
  Format.formatter ->
  (Type_base.var list * Type_base.t) ->
  unit

val string_of_type : ?generalized:Type_base.var list -> Type_base.t -> string

String representation of a type.

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

String representation of a type scheme.

type explanation = bool * Type_base.t * Type_base.t * t * t

exception Type_error of explanation

val print_type_error : 
  formatter:Format.formatter ->
  (Pos.Option.t -> 'a) ->
  explanation ->
  unit