Module `Dcalc.Ast`Source

Abstract syntax tree of the default calculus intermediate representation

Sourcemodule ScopeName : Utils.Uid.Id with type info = Utils.Uid.MarkedString.info

Sourcemodule StructName : Utils.Uid.Id with type info = Utils.Uid.MarkedString.info

module StructFieldName : 
  Utils.Uid.Id with type info = Utils.Uid.MarkedString.info

Sourcemodule StructMap : Map.S with type key = StructName.t

Sourcemodule EnumName : Utils.Uid.Id with type info = Utils.Uid.MarkedString.info

Source

module EnumConstructor : 
  Utils.Uid.Id with type info = Utils.Uid.MarkedString.info

Sourcemodule EnumMap : Map.S with type key = EnumName.t

Abstract syntax tree for the default calculus

Abstract syntax tree

Sourcetype typ_lit =

| TBool
| TUnit
| TInt
| TRat
| TMoney
| TDate
| TDuration

Sourcetype typ =

| TLit of typ_lit
| TTuple of typ Utils.Pos.marked list * StructName.t option
| TEnum of typ Utils.Pos.marked list * EnumName.t
| TArrow of typ Utils.Pos.marked * typ Utils.Pos.marked
| TArray of typ Utils.Pos.marked
| TAny

Sourcetype date = Runtime.date

Sourcetype duration = Runtime.duration

Sourcetype lit =

| LBool of bool
| LEmptyError
| LInt of Runtime.integer
| LRat of Runtime.decimal
| LMoney of Runtime.money
| LUnit
| LDate of date
| LDuration of duration

Sourcetype op_kind =

| KInt
| KRat
| KMoney
| KDate
| KDuration
(*
All ops don't have a KDate and KDuration.
*)

Sourcetype ternop =

| Fold

Sourcetype binop =

| And
| Or
| Xor
| Add of op_kind
| Sub of op_kind
| Mult of op_kind
| Div of op_kind
| Lt of op_kind
| Lte of op_kind
| Gt of op_kind
| Gte of op_kind
| Eq
| Neq
| Map
| Concat
| Filter

Sourcetype log_entry =

| VarDef of typ
(*
During code generation, we need to know the type of the variable being logged for embedding
*)
| BeginCall
| EndCall
| PosRecordIfTrueBool

Sourcetype unop =

| Not
| Minus of op_kind
| Log of log_entry * Utils.Uid.MarkedString.info list
| Length
| IntToRat
| GetDay
| GetMonth
| GetYear

Sourcetype operator =

| Ternop of ternop
| Binop of binop
| Unop of unop

Sourcetype expr =

| EVar of expr Bindlib.var Utils.Pos.marked
| ETuple of expr Utils.Pos.marked list * StructName.t option
(*
The MarkedString.info is the former struct field name
*)
| ETupleAccess of expr Utils.Pos.marked * int * StructName.t option * typ Utils.Pos.marked list
(*
The MarkedString.info is the former struct field name
*)
| EInj of expr Utils.Pos.marked * int * EnumName.t * typ Utils.Pos.marked list
(*
The MarkedString.info is the former enum case name
*)
| EMatch of expr Utils.Pos.marked * expr Utils.Pos.marked list * EnumName.t
(*
The MarkedString.info is the former enum case name
*)
| EArray of expr Utils.Pos.marked list
| ELit of lit
| EAbs of (expr, expr Utils.Pos.marked) Bindlib.mbinder Utils.Pos.marked * typ Utils.Pos.marked list
| EApp of expr Utils.Pos.marked * expr Utils.Pos.marked list
| EAssert of expr Utils.Pos.marked
| EOp of operator
| EDefault of expr Utils.Pos.marked list * expr Utils.Pos.marked * expr Utils.Pos.marked
| EIfThenElse of expr Utils.Pos.marked * expr Utils.Pos.marked * expr Utils.Pos.marked
| ErrorOnEmpty of expr Utils.Pos.marked

The expressions use the Bindlib library, based on higher-order abstract syntax

Sourcetype struct_ctx = (StructFieldName.t * typ Utils.Pos.marked) list StructMap.t

Sourcetype enum_ctx = (EnumConstructor.t * typ Utils.Pos.marked) list EnumMap.t

Sourcetype decl_ctx = {

ctx_enums : enum_ctx;
ctx_structs : struct_ctx;

}

Sourcetype binder = (expr, expr Utils.Pos.marked) Bindlib.binder

Sourcetype scope_let_kind =

| DestructuringInputStruct
(*
let x = input.field
*)
| ScopeVarDefinition
(*
let x = error_on_empty e
*)
| SubScopeVarDefinition
(*
let s.x = fun _ -> e or let s.x = error_on_empty e for input-only subscope variables.
*)
| CallingSubScope
(*
let result = s ({ x = s.x; y = s.x; ...})
*)
| DestructuringSubScopeResults
(*
let s.x = result.x *
*)
| Assertion
(*
let _ = assert e
*)

This kind annotation signals that the let-binding respects a structural invariant. These invariants concern the shape of the expression in the let-binding, and are documented below.

Sourcetype scope_let = {

scope_let_var : expr Bindlib.var Utils.Pos.marked;
scope_let_kind : scope_let_kind;
scope_let_typ : typ Utils.Pos.marked;
scope_let_expr : expr Utils.Pos.marked Bindlib.box;

}

A scope let-binding has all the information necessary to make a proper let-binding expression, plus an annotation for the kind of the let-binding that comes from the compilation of a Scopelang.Ast statement.

Sourcetype scope_body = {

scope_body_lets : scope_let list;
scope_body_result : expr Utils.Pos.marked Bindlib.box;
scope_body_arg : expr Bindlib.var;
scope_body_input_struct : StructName.t;
scope_body_output_struct : StructName.t;

}

Instead of being a single expression, we give a little more ad-hoc structure to the scope body by decomposing it in an ordered list of let-bindings, and a result expression that uses the let-binded variables.

Sourcetype program = {

decl_ctx : decl_ctx;
scopes : (ScopeName.t * expr Bindlib.var * scope_body) list;

}

Helpers

Variables

Sourcemodule Var : sig ... end

Sourcemodule VarMap : Map.S with type key = Var.t

Sourceval free_vars_set : expr Utils.Pos.marked -> unit VarMap.t

Sourceval free_vars_list : expr Utils.Pos.marked -> Var.t list

Sourcetype vars = expr Bindlib.mvar

Sourceval make_var : Var.t Utils.Pos.marked -> expr Utils.Pos.marked Bindlib.box

Source

val make_abs : 
  vars ->
  expr Utils.Pos.marked Bindlib.box ->
  Utils.Pos.t ->
  typ Utils.Pos.marked list ->
  Utils.Pos.t ->
  expr Utils.Pos.marked Bindlib.box

Source

val make_app : 
  expr Utils.Pos.marked Bindlib.box ->
  expr Utils.Pos.marked Bindlib.box list ->
  Utils.Pos.t ->
  expr Utils.Pos.marked Bindlib.box

Source

val make_let_in : 
  Var.t ->
  typ Utils.Pos.marked ->
  expr Utils.Pos.marked Bindlib.box ->
  expr Utils.Pos.marked Bindlib.box ->
  Utils.Pos.t ->
  expr Utils.Pos.marked Bindlib.box

Other

Sourceval empty_thunked_term : expr Utils.Pos.marked

Sourceval is_value : expr Utils.Pos.marked -> bool

AST manipulation helpers

Source

val build_whole_scope_expr : 
  decl_ctx ->
  scope_body ->
  Utils.Pos.t ->
  expr Utils.Pos.marked Bindlib.box

Usage: build_whole_scope_expr ctx body scope_position where scope_position corresponds to the line of the scope declaration for instance.

Source

val build_whole_program_expr : 
  program ->
  ScopeName.t ->
  expr Utils.Pos.marked Bindlib.box

Usage: build_whole_program_expr program main_scope builds an expression corresponding to the main program and returning the main scope as a function.

Sourceval expr_size : expr Utils.Pos.marked -> int

Used by the optimizer to know when to stop

Sourceval variable_types : program -> typ Utils.Pos.marked VarMap.t

Traverses all the scopes and retrieves all the types for the variables that may appear in scope or subscope variable definitions, giving them as a big map.

Install

Dune Dependency

Authors

Maintainers

Sources

doc/catala.dcalc/Dcalc/Ast/index.html

Module `Dcalc.Ast`Source

Abstract syntax tree

Helpers

Variables

Other

AST manipulation helpers

package catala

Install

Dune Dependency

Authors

Maintainers

Sources

doc/catala.dcalc/Dcalc/Ast/index.html

Module Dcalc.AstSource

Abstract syntax tree

Helpers

Variables

Other

AST manipulation helpers

Module `Dcalc.Ast`Source