package catala

You can search for identifiers within the package.

in-package search v0.2.0

package catala

catala.catala_utils
- Catala_utils
  - Cli
    
    Flags
    
    Global
  - File
    
    Map
    
    Set
    
    Tree
  - Map
    
    Make
    
    Ord
    
    OrderedType
    
    S
  - Mark
    
    marked_iter
    
    marked_map
    
    pos_iter
    
    pos_map
  - Message
    
    Content
  - Pos
  - String
    
    Map
    
    Set
  - Suggestions
  - Uid
    
    Gen
    
    Map
    
    Set
    
    _
    
    Gen_qualified
    
    Map
    
    Set
    
    _
    
    Id
    
    Map
    
    Set
    
    Info
    
    Make
    
    Map
    
    Set
    
    X
    
    _
    
    MarkedString
    
    Module
    
    Map
    
    Set
    
    Path
    
    Style
  - Version
catala.clerk_driver
- Clerk_driver
catala.dcalc
- Dcalc
catala.desugared
- Desugared
  - Ast
    
    AssertionName
    
    Map
    
    Set
    
    ExprMap
    
    LocationSet
    
    Rule
    
    ScopeDef
    
    Map
    
    Set
  - Dependency
    
    Edge
    
    EdgeExceptions
    
    ExceptionVertex
    
    ExceptionsDependencies
    
    E
    
    V
    
    ScopeDependencies
    
    E
    
    V
    
    Vertex
  - Disambiguate
  - From_surface
  - Linting
  - Name_resolution
  - Print
catala.driver
- Driver
  - Commands
  - Passes
  - Plugin
catala.lcalc
- Lcalc
catala.literate
- Literate
  - Html
  - Latex
  - Literate_common
  - Pygment_lexers
    
    Internal
  - Pygmentize
catala.plugins.api_web
- Api_web
  - To_jsoo
catala.plugins.explain
- Explain
  - E
  - Env
  - G
    
    E
    
    V
  - GTopo
  - V
catala.plugins.json_schema
- Json_schema
  - To_json
catala.plugins.lazy-interpreter
- Lazy_interpreter
  - Lazy_interp
    
    Env
catala.plugins.python
- Python
catala.runtime_jsoo
- Runtime_jsoo
  - Runtime
    
    duration
    
    event
    
    event_manager
    
    raw_event
    
    source_position
catala.runtime_ocaml
- Runtime_ocaml
  - Runtime
    
    Eoption
    
    EventParser
    
    Oper
catala.scalc
- Scalc
  - Ast
    
    FuncName
    
    Map
    
    Set
    
    VarName
    
    Map
    
    Set
  - From_lcalc
  - Print
  - To_python
  - To_r
catala.scopelang
- Scopelang
  - Ast
    
    LocationSet
  - Dependency
    
    SDependencies
    
    E
    
    V
    
    TDependencies
    
    E
    
    V
    
    TVertex
    
    TVertexSet
  - From_desugared
  - Print
catala.shared_ast
- Shared_ast
  - EnumConstructor
    
    Map
    
    Set
  - EnumName
    
    Map
    
    Set
  - Expr
    
    Box
  - Interpreter
  - LabelName
    
    Map
    
    Set
  - Op
  - Operator
  - Optimizations
  - Print
    
    EXPR_PARAM
    
    ExprConciseParam
    
    ExprDebugParam
    
    ExprGen
    
    _
    
    UserFacing
  - Program
  - Qident
    
    Map
    
    Set
  - RuleName
    
    Map
    
    Set
  - Scope
  - ScopeName
    
    Map
    
    Set
  - ScopeVar
    
    Map
    
    Set
  - StateName
    
    Map
    
    Set
  - StructField
    
    Map
    
    Set
  - StructName
    
    Map
    
    Set
  - SubScopeName
    
    Map
    
    Set
  - TopdefName
    
    Map
    
    Set
  - Type
  - Typing
    
    Env
  - Var
    
    Map
    
    Set
catala.surface
- Surface
  - Ast
    
    map
  - Fill_positions
  - Lexer_common
    
    LocalisedLexer
  - Lexer_en
  - Lexer_fr
  - Lexer_pl
  - Parser
    
    Make
    
    Incremental
    
    Localisation
    
    MenhirInterpreter
  - Parser_driver
  - Parser_errors
  - Print
  - Tokens
catala.verification
- Verification
  - Conditions
  - Globals
  - Io
    
    Backend
    
    BackendIO
    
    MakeBackendIO
    
    B
  - Solver
  - Z3backend
    
    Io

Legend:
Library
Module
Module type
Parameter
Class
Class type

type flags = {

with_conditions : bool;
with_cleanup : bool;
merge_level : int;
format : [ `Dot | `Convert of string ];
show : string option;
output : Catala_utils.Cli.raw_file option;
base_src_url : string;

}

val log : ('a, Format.formatter, unit, unit, unit, unit) format6 -> 'b

val error : 
  ('a, 'b Shared_ast__.Definitions.mark) Catala_utils.Mark.ed ->
  ('c, Format.formatter, unit, 'd) format4 ->
  'c

val noassert : bool

module Env : sig ... end

type expr = Env.expr

type annot = Env.annot = {

conditions : (expr * Env.t) list;

}

type laziness_level = {

eval_struct : bool;
eval_op : bool;
eval_match : bool;
eval_default : bool;
eval_vars : expr Shared_ast.Var.t -> bool;

}

val value_level : laziness_level

val add_condition : 
  condition:(expr * Env.t) ->
  ('a, annot Shared_ast.custom Shared_ast.mark) Catala_utils.Mark.ed ->
  ('a, annot Shared_ast.custom Shared_ast.mark) Catala_utils.Mark.ed

val add_conditions : 
  conditions:(expr * Env.t) list ->
  ('a, annot Shared_ast.custom Shared_ast.mark) Catala_utils.Mark.ed ->
  ('a, annot Shared_ast.custom Shared_ast.mark) Catala_utils.Mark.ed

val neg_op : 
  < monomorphic : Shared_ast__Definitions.yes
    ; resolved : Shared_ast__Definitions.yes.. >
    Shared_ast.Op.t ->
  < polymorphic : Shared_ast__Definitions.yes
    ; resolved : Shared_ast__Definitions.yes.. >
    Shared_ast.Op.t
    option

val bool_negation : 
  ((< monomorphic : Shared_ast__Definitions.yes
     ; polymorphic : Shared_ast__Definitions.yes
     ; resolved : Shared_ast__Definitions.yes.. > as 'a,
     < monomorphic : Shared_ast__Definitions.yes
     ; polymorphic : Shared_ast__Definitions.yes
     ; resolved : Shared_ast__Definitions.yes.. > as 'a,
     'b)
     Shared_ast__.Definitions.base_gexpr,
    'b Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  ('c, 'd, 'e) Shared_ast.base_gexpr * 'f Shared_ast__.Definitions.mark

val lazy_eval : 
  Shared_ast.decl_ctx ->
  Env.t ->
  laziness_level ->
  expr ->
  expr * Env.t

val result_level : 
  ((Shared_ast.dcalc, Shared_ast.dcalc, Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed
    Shared_ast.Var.Set.t ->
  laziness_level

val interpret_program : 
  (Shared_ast.dcalc Shared_ast__.Definitions.any Shared_ast__.Definitions.any
     Shared_ast.any
     Shared_ast.any
     Shared_ast.any
     Shared_ast.any
     Shared_ast.any
     Shared_ast.any,
    Env.annot Shared_ast.custom)
    Shared_ast.gexpr
    Shared_ast.program ->
  Shared_ast.ScopeName.t ->
  (Shared_ast.dcalc, Env.annot Shared_ast.custom) Shared_ast.gexpr * Env.t

val print_value_with_env : 
  Shared_ast.decl_ctx ->
  Format.formatter ->
  Env.t ->
  ((Shared_ast.dcalc Shared_ast__.Definitions.any,
     Shared_ast.dcalc Shared_ast__.Definitions.any,
     Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  unit

module V : sig ... end

module E : sig ... end

module G : sig ... end

val op_kind : 
  < polymorphic : Shared_ast__Definitions.yes
    ; resolved : Shared_ast__Definitions.yes.. >
    Shared_ast.Op.t ->
  [> `Fct | `Other | `Product | `Round | `Sum ]

module GTopo : sig ... end

val to_graph : 
  'a ->
  Env.t ->
  ((Shared_ast.dcalc, Shared_ast.dcalc, Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  G.t

val is_const : 
  ((< .. >, < .. >, 'a) Shared_ast__.Definitions.base_gexpr,
    'a Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  bool

val program_to_graph : 
  flags ->
  (Shared_ast.dcalc, 'm) Shared_ast.gexpr Shared_ast.program ->
  Shared_ast.ScopeName.t ->
  G.t * expr Shared_ast.Var.Set.t * Env.t

val reverse_graph : G.t -> G.t

val subst_by : 
  (('a, 'a, 'b) Shared_ast__.Definitions.base_gexpr,
    'b Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed
    Shared_ast.Var.t ->
  (('c, 'c, 'd) Shared_ast__.Definitions.base_gexpr,
    'd Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  (('e, 'e, 'f) Shared_ast__.Definitions.base_gexpr,
    'f Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  (('g, 'g, 'h) Shared_ast__.Definitions.base_gexpr,
    'h Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed

val map_vertices : (G.vertex -> G.V.label) -> G.t -> G.t

val graph_cleanup : 
  flags ->
  G.t ->
  ((Shared_ast.dcalc, Shared_ast.dcalc, Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed
    Shared_ast.Var.Set.t ->
  G.t

val expr_to_dot_label0 : 
  'a. Catala_utils.Cli.backend_lang ->
  Shared_ast.decl_ctx ->
  Env.t ->
  Format.formatter ->
  ('a, 't) Shared_ast.gexpr ->
  unit

val expr_to_dot_label : 
  Catala_utils.Cli.backend_lang ->
  Shared_ast.decl_ctx ->
  Env.t ->
  Format.formatter ->
  ((< assertions : Shared_ast.yes
     ; custom : Shared_ast.no
     ; defaultTerms : Shared_ast.yes
     ; exceptions : Shared_ast.no
     ; explicitScopes : Shared_ast.no
     ; monomorphic : Shared_ast.yes
     ; overloaded : Shared_ast.no
     ; polymorphic : Shared_ast.yes
     ; resolved : Shared_ast.yes
     ; scopeVarSimpl : Shared_ast.no
     ; scopeVarStates : Shared_ast.no
     ; syntacticNames : Shared_ast.no >,
     < assertions : Shared_ast.yes
     ; custom : Shared_ast.no
     ; defaultTerms : Shared_ast.yes
     ; exceptions : Shared_ast.no
     ; explicitScopes : Shared_ast.no
     ; monomorphic : Shared_ast.yes
     ; overloaded : Shared_ast.no
     ; polymorphic : Shared_ast.yes
     ; resolved : Shared_ast.yes
     ; scopeVarSimpl : Shared_ast.no
     ; scopeVarStates : Shared_ast.no
     ; syntacticNames : Shared_ast.no >,
     Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed ->
  unit

val to_dot : 
  Catala_utils.Cli.backend_lang ->
  Format.formatter ->
  Shared_ast.decl_ctx ->
  Env.t ->
  ((Shared_ast.dcalc, Shared_ast.dcalc, Env.annot Shared_ast.custom)
     Shared_ast__.Definitions.base_gexpr,
    Env.annot Shared_ast.custom Shared_ast__.Definitions.mark)
    Catala_utils.Mark.ed
    Shared_ast.Var.Set.t ->
  G.t ->
  base_src_url:string ->
  unit

val options : flags Cmdliner.Term.t

val run : 
  Catala_utils.Cli.raw_file list ->
  bool ->
  string ->
  flags ->
  Catala_utils.Cli.options ->
  unit

val term : (Catala_utils.Cli.options -> unit) Cmdliner.Term.t