package catala

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

AST
1. Expressions
2. Rules and scopes
Helpers

package catala

catala.catala_utils
- Catala_utils
  - Cli
    
    Flags
    
    Global
  - File
    
    Map
    
    Tree
  - Global
  - Map
    
    Make
    
    Ord
    
    OrderedType
    
    S
  - Mark
    
    marked_iter
    
    marked_map
    
    pos_iter
    
    pos_map
  - Message
    
    Content
  - Pos
  - String
    
    Map
  - Suggestions
  - Uid
    
    Gen
    
    Map
    
    _
    
    Gen_qualified
    
    Map
    
    _
    
    Id
    
    Map
    
    Info
    
    Make
    
    Map
    
    X
    
    _
    
    MarkedString
    
    Module
    
    Map
    
    Path
    
    Style
  - Version
catala.clerk_driver
- Clerk_driver
catala.dcalc
- Dcalc
catala.desugared
- Desugared
  - Ast
    
    AssertionName
    
    Map
    
    ExprMap
    
    ScopeDef
    
    Map
  - Dependency
    
    ExceptionVertex
    
    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
    
    Json
    
    Oper
catala.scalc
- Scalc
  - Ast
    
    FuncName
    
    Map
    
    Set
    
    VarName
    
    Map
    
    Set
  - From_lcalc
  - Print
  - To_c
  - To_python
  - To_r
catala.scopelang
- Scopelang
  - Ast
  - Dependency
    
    TVertex
  - From_desugared
  - Print
catala.shared_ast
- Shared_ast
  - BoundList
  - EnumConstructor
    
    Map
    
    Set
  - EnumName
    
    Map
    
    Set
  - Expr
    
    Box
  - Interpreter
  - LabelName
    
    Map
    
    Set
  - Op
  - Operator
  - Optimizations
  - Print
    
    EXPR_PARAM
    
    ExprConciseParam
    
    ExprDebugParam
    
    ExprGen
    
    _
    
    UserFacing
  - Program
  - Qident
  - RuleName
    
    Map
    
    Set
  - Scope
  - ScopeName
    
    Map
    
    Set
  - ScopeVar
    
    Map
    
    Set
  - StateName
    
    Map
    
    Set
  - StructField
    
    Map
    
    Set
  - StructName
    
    Map
    
    Set
  - TopdefName
    
    Map
    
    Set
  - Type
    
    Map
  - 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

Abstract syntax tree of the desugared representation

module ScopeDef : sig ... end

Inside a scope, a definition can refer to a variable (possibly an intermediate state thereof) or an input of a subscope.

module AssertionName : 
  Catala_utils.Uid.Id with type info = Catala_utils.Uid.MarkedString.info

AST

Expressions

type expr = (Shared_ast.desugared, Shared_ast.untyped) Shared_ast.gexpr

See Shared_ast.naked_gexpr for the complete definition

type location = Shared_ast.desugared Shared_ast.glocation

module LocationSet : 
  Stdlib.Set.S with type elt = location Catala_utils.Mark.pos

module ExprMap : Catala_utils.Map.S with type key = expr

Rules and scopes

type exception_situation =

| BaseCase
| ExceptionToLabel of Shared_ast.LabelName.t Catala_utils.Mark.pos
| ExceptionToRule of Shared_ast.RuleName.t Catala_utils.Mark.pos

type label_situation =

| ExplicitlyLabeled of Shared_ast.LabelName.t Catala_utils.Mark.pos
| Unlabeled

type rule = {

rule_id : Shared_ast.RuleName.t;
rule_just : expr Shared_ast.boxed;
rule_cons : expr Shared_ast.boxed;
rule_parameter : (expr Shared_ast.Var.t Catala_utils.Mark.pos * Shared_ast.typ) list Catala_utils.Mark.pos option;
rule_exception : exception_situation;
rule_label : label_situation;

}

module Rule : Stdlib.Set.OrderedType with type t = rule

val empty_rule : 
  Catala_utils.Pos.t ->
  (Catala_utils.Uid.MarkedString.info * Shared_ast.typ) list
    Catala_utils.Mark.pos
    option ->
  rule

val always_false_rule : 
  Catala_utils.Pos.t ->
  (Catala_utils.Uid.MarkedString.info * Shared_ast.typ) list
    Catala_utils.Mark.pos
    option ->
  rule

type assertion = expr Shared_ast.boxed

type variation_typ =

| Increasing
| Decreasing

type reference_typ =

| Decree
| Law

type catala_option =

| DateRounding of variation_typ

type meta_assertion =

| FixedBy of reference_typ Catala_utils.Mark.pos
| VariesWith of unit * variation_typ Catala_utils.Mark.pos option

type io = {

io_output : bool Catala_utils.Mark.pos;
(*
true is present in the output of the scope.
*)
io_input : Shared_ast.Runtime.io_input Catala_utils.Mark.pos;

}

Characterization of the input/output status of a scope variable.

type scope_def = {

scope_def_rules : rule Shared_ast.RuleName.Map.t;
(*
empty outside of the root module
*)
scope_def_typ : Shared_ast.typ;
scope_def_parameters : (Catala_utils.Uid.MarkedString.info * Shared_ast.typ) list Catala_utils.Mark.pos option;
scope_def_is_condition : bool;
scope_def_io : io;

}

type var_or_states =

| WholeVar
| States of Shared_ast.StateName.t list

type scope = {

scope_vars : var_or_states Shared_ast.ScopeVar.Map.t;
scope_sub_scopes : Shared_ast.ScopeName.t Shared_ast.ScopeVar.Map.t;
scope_uid : Shared_ast.ScopeName.t;
scope_defs : scope_def ScopeDef.Map.t;
scope_assertions : assertion AssertionName.Map.t;
(*
empty outside of the root module
*)
scope_options : catala_option Catala_utils.Mark.pos list;
scope_meta_assertions : meta_assertion list;

}

type modul = {

module_scopes : scope Shared_ast.ScopeName.Map.t;
module_topdefs : (expr option * Shared_ast.typ) Shared_ast.TopdefName.Map.t;
(*
the expr is None outside of the root module
*)

}

type program = {

program_module_name : Shared_ast.Ident.t Catala_utils.Mark.pos option;
program_ctx : Shared_ast.decl_ctx;
program_modules : modul Shared_ast.ModuleName.Map.t;
(*
Contains all submodules of the program, in a flattened structure
*)
program_root : modul;
program_lang : Catala_utils.Global.backend_lang;

}

Helpers

val locations_used : expr -> LocationSet.t

val free_variables : 
  rule Shared_ast.RuleName.Map.t ->
  Catala_utils.Pos.t ScopeDef.Map.t

val fold_exprs : f:('a -> expr -> 'a) -> init:'a -> program -> 'a

Usage: fold_exprs ~f ~init program applies ~f to all the expressions inside rules (justifications and consequences), expressions and top-level definitions of the program. Note that there may be free variables in these expressions.