package catala

You can search for identifiers within the package.

in-package search v0.2.0

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

Bound lists are non-empty linked lists where each element is a binder onto the next. They are useful for ordered program definitions, like nested let-ins.

let a = e1 in e2 is thus represented as Cons (e1, {a. Last e2}).

The following provides a few utility functions for their traversal and manipulation. In particular, map functions take care of unbinding, then properly rebinding the variables.

type ('e, 'elt, 'last) t =

| Last of 'last

val last : (_, _, 'a) t -> 'a

val iter : f:('e Var.t -> 'elt -> unit) -> ('e, 'elt, 'last) t -> 'last

val find : f:('elt -> 'a option) -> (_, 'elt, _) t -> 'a

val fold_left : 
  f:('acc -> 'elt -> 'e Var.t -> 'acc) ->
  init:'acc ->
  ('e, 'elt, 'last) t ->
  'acc * 'last

val fold_left2 : 
  f:('acc -> 'elt1 -> 'elt2 -> 'e Var.t -> 'acc) ->
  init:'acc ->
  ('e, 'elt1, 'last1) t ->
  ('e, 'elt2, 'last2) t ->
  'acc * ('last1 * 'last2)

val fold_right : 
  f:('elt -> 'e Var.t -> 'acc -> 'acc) ->
  init:('last -> 'acc) ->
  ('e, 'elt, 'last) t ->
  'acc

val fold_lr : 
  top:'dacc ->
  down:('e Var.t -> 'elt -> 'dacc -> 'dacc) ->
  bottom:('last -> 'dacc -> 'uacc) ->
  up:('e Var.t -> 'elt -> 'uacc -> 'uacc) ->
  ('e, 'elt, 'last) t ->
  'uacc

Bi-directional fold: down accumulates downwards, starting from top; upon reaching last, bottom is called; then up accumulates on the way back up

val map : 
  f:('e1 Var.t -> 'elt1 -> 'e2 Var.t * 'elt2 Bindlib.box) ->
  last:('last1 -> 'last2 Bindlib.box) ->
  ('e1, 'elt1, 'last1) t ->
  ('e2, 'elt2, 'last2) t Bindlib.box

val fold_map : 
  f:('ctx -> 'e1 Var.t -> 'elt1 -> 'ctx * 'e2 Var.t * 'elt2 Bindlib.box) ->
  last:('ctx -> 'last1 -> 'ret * 'last2 Bindlib.box) ->
  init:'ctx ->
  ('e1, 'elt1, 'last1) t ->
  'ret * ('e2, 'elt2, 'last2) t Bindlib.box

val equal : 
  f:('elt -> 'elt -> bool) ->
  last:('last -> 'last -> bool) ->
  ('e, 'elt, 'last) t as 'l ->
  'l ->
  bool

val compare : 
  f:('elt -> 'elt -> int) ->
  last:('last -> 'last -> int) ->
  ('e, 'elt, 'last) t as 'l ->
  'l ->
  int