package catala

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Catala operator utilities
1. Getting the types of operators
2. Overload handling

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

Catala operator utilities

Resolving operators from the surface syntax proceeds in three steps:

During desugaring, the operators may remain untyped (with TAny) or, if they have an explicit type suffix (e.g. the $ for "money" in +$), their operands types are already explicited in the EOp expression node.

Shared_ast.Typing will then enforce these constraints in addition to the known built-in type for each operator (e.g. Eq: 'a -> 'a -> 'a isn't encoded in the first-order AST types).

Finally, during Scopelang.From_desugared, these types are leveraged to resolve the overloaded operators to their concrete, monomorphic counterparts

type monomorphic = < monomorphic : Shared_ast__.Definitions.yes >

Operands and return types of the operator are fixed

type polymorphic = < polymorphic : Shared_ast__.Definitions.yes >

The operator is truly polymorphic: it's the same runtime function that may work on multiple types. We require that resolving the argument types from right to left trivially resolves all type variables declared in the operator type.

type overloaded = < overloaded : Shared_ast__.Definitions.yes >

The operator is ambiguous and requires the types of its arguments to be known before it can be typed, using a pre-defined table

type resolved = < resolved : Shared_ast__.Definitions.yes >

Explicit monomorphic versions of the overloaded operators

type _ t =

| Not : < monomorphic.. > t
| GetDay : < monomorphic.. > t
| GetMonth : < monomorphic.. > t
| GetYear : < monomorphic.. > t
| FirstDayOfMonth : < monomorphic.. > t
| LastDayOfMonth : < monomorphic.. > t
| Length : < polymorphic.. > t
| ToClosureEnv : < polymorphic.. > t
| FromClosureEnv : < polymorphic.. > t
| Minus : < overloaded.. > t
| Minus_int : < resolved.. > t
| Minus_rat : < resolved.. > t
| Minus_mon : < resolved.. > t
| Minus_dur : < resolved.. > t
| ToRat : < overloaded.. > t
| ToRat_int : < resolved.. > t
| ToRat_mon : < resolved.. > t
| ToMoney : < overloaded.. > t
| ToMoney_rat : < resolved.. > t
| Round : < overloaded.. > t
| Round_rat : < resolved.. > t
| Round_mon : < resolved.. > t
| And : < monomorphic.. > t
| Or : < monomorphic.. > t
| Xor : < monomorphic.. > t
| Eq : < polymorphic.. > t
| Map : < polymorphic.. > t
| Map2 : < polymorphic.. > t
| Concat : < polymorphic.. > t
| Filter : < polymorphic.. > t
| Add : < overloaded.. > t
| Add_int_int : < resolved.. > t
| Add_rat_rat : < resolved.. > t
| Add_mon_mon : < resolved.. > t
| Add_dat_dur : Runtime_ocaml.Runtime.date_rounding -> < resolved.. > t
| Add_dur_dur : < resolved.. > t
| Sub : < overloaded.. > t
| Sub_int_int : < resolved.. > t
| Sub_rat_rat : < resolved.. > t
| Sub_mon_mon : < resolved.. > t
| Sub_dat_dat : < resolved.. > t
| Sub_dat_dur : < resolved.. > t
| Sub_dur_dur : < resolved.. > t
| Mult : < overloaded.. > t
| Mult_int_int : < resolved.. > t
| Mult_rat_rat : < resolved.. > t
| Mult_mon_rat : < resolved.. > t
| Mult_dur_int : < resolved.. > t
| Div : < overloaded.. > t
| Div_int_int : < resolved.. > t
| Div_rat_rat : < resolved.. > t
| Div_mon_rat : < resolved.. > t
| Div_mon_mon : < resolved.. > t
| Div_dur_dur : < resolved.. > t
| Lt : < overloaded.. > t
| Lt_int_int : < resolved.. > t
| Lt_rat_rat : < resolved.. > t
| Lt_mon_mon : < resolved.. > t
| Lt_dat_dat : < resolved.. > t
| Lt_dur_dur : < resolved.. > t
| Lte : < overloaded.. > t
| Lte_int_int : < resolved.. > t
| Lte_rat_rat : < resolved.. > t
| Lte_mon_mon : < resolved.. > t
| Lte_dat_dat : < resolved.. > t
| Lte_dur_dur : < resolved.. > t
| Gt : < overloaded.. > t
| Gt_int_int : < resolved.. > t
| Gt_rat_rat : < resolved.. > t
| Gt_mon_mon : < resolved.. > t
| Gt_dat_dat : < resolved.. > t
| Gt_dur_dur : < resolved.. > t
| Gte : < overloaded.. > t
| Gte_int_int : < resolved.. > t
| Gte_rat_rat : < resolved.. > t
| Gte_mon_mon : < resolved.. > t
| Gte_dat_dat : < resolved.. > t
| Gte_dur_dur : < resolved.. > t
| Eq_int_int : < resolved.. > t
| Eq_rat_rat : < resolved.. > t
| Eq_mon_mon : < resolved.. > t
| Eq_dur_dur : < resolved.. > t
| Eq_dat_dat : < resolved.. > t
| Reduce : < polymorphic.. > t
| Fold : < polymorphic.. > t
| HandleDefault : < polymorphic.. > t
| HandleDefaultOpt : < polymorphic.. > t

val equal : 'a1 t -> 'a2 t -> bool

val compare : 'a1 t -> 'a2 t -> int

val name : 'a t -> string

Returns the operator name as a valid ident starting with a lowercase character. This is different from Print.operator which returns operator symbols, e.g. +$.

val kind_dispatch : 
  polymorphic:
    (< polymorphic : Shared_ast__.Definitions.yes.. > t Catala_utils.Mark.pos ->
      'b) ->
  monomorphic:
    (< monomorphic : Shared_ast__.Definitions.yes.. > t Catala_utils.Mark.pos ->
      'b) ->
  ?overloaded:
    (< overloaded : Shared_ast__.Definitions.yes.. > t Catala_utils.Mark.pos ->
      'b) ->
  ?resolved:
    (< resolved : Shared_ast__.Definitions.yes.. > t Catala_utils.Mark.pos ->
      'b) ->
  'a t Catala_utils.Mark.pos ->
  'b

Calls one of the supplied functions depending on the kind of the operator

type 'a no_overloads =
  < overloaded : Shared_ast__.Definitions.no
  ; monomorphic : Shared_ast__.Definitions.yes
  ; polymorphic : Shared_ast__.Definitions.yes
  ; resolved : Shared_ast__.Definitions.yes.. > as 'a

val translate : 
  'a no_overloads t Catala_utils.Mark.pos ->
  'b no_overloads t Catala_utils.Mark.pos

An identity function that allows translating an operator between different passes that don't change operator types

Getting the types of operators

val monomorphic_type : 
  monomorphic t Catala_utils.Mark.pos ->
  Shared_ast__.Definitions.naked_typ Catala_utils.Mark.pos

val resolved_type : 
  resolved t Catala_utils.Mark.pos ->
  Shared_ast__.Definitions.naked_typ Catala_utils.Mark.pos

val overload_type : 
  Shared_ast__.Definitions.decl_ctx ->
  overloaded t Catala_utils.Mark.pos ->
  Shared_ast__.Definitions.naked_typ Catala_utils.Mark.pos list ->
  Shared_ast__.Definitions.naked_typ Catala_utils.Mark.pos

The type for typing overloads is different since the types of the operands are required in advance.

raises a
detailed user error if no matching operator can be found

Polymorphic operators are typed directly within Typing, since their types may contain type variables that can't be expressed outside of it

Overload handling

val resolve_overload : 
  Shared_ast__.Definitions.decl_ctx ->
  overloaded t Catala_utils.Mark.pos ->
  Shared_ast__.Definitions.naked_typ Catala_utils.Mark.pos list ->
  < resolved : Shared_ast__.Definitions.yes.. > t Catala_utils.Mark.pos
  * [ `Straight | `Reversed ]

Some overloads are sugar for an operation with reversed operands, e.g. TRat * TMoney is using mult_mon_rat. `Reversed is returned to signify this case.