Ast (p.catala.0.7.0.doc.catala.scopelang.Scopelang.Ast)

Identifiers

Sourcemodule ScopeName = Dcalc.Ast.ScopeName

Sourcemodule ScopeNameSet : Set.S with type elt = ScopeName.t

Sourcemodule ScopeMap : Map.S with type key = ScopeName.t

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

Sourcemodule SubScopeNameSet : Set.S with type elt = SubScopeName.t

Sourcemodule SubScopeMap : Map.S with type key = SubScopeName.t

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

Sourcemodule ScopeVarSet : Set.S with type elt = ScopeVar.t

Sourcemodule ScopeVarMap : Map.S with type key = ScopeVar.t

Sourcemodule StructName = Dcalc.Ast.StructName

Sourcemodule StructMap = Dcalc.Ast.StructMap

Sourcemodule StructFieldName = Dcalc.Ast.StructFieldName

Sourcemodule StructFieldMap : Map.S with type key = StructFieldName.t

module StructFieldMapLift : sig ... end

Sourcemodule EnumName = Dcalc.Ast.EnumName

Sourcemodule EnumMap = Dcalc.Ast.EnumMap

Sourcemodule EnumConstructor = Dcalc.Ast.EnumConstructor

Sourcemodule EnumConstructorMap : Map.S with type key = EnumConstructor.t

module EnumConstructorMapLift : sig ... end

Sourcetype location =

| ScopeVar of ScopeVar.t Utils.Marked.pos
| SubScopeVar of ScopeName.t * SubScopeName.t Utils.Marked.pos * ScopeVar.t Utils.Marked.pos

Sourcemodule LocationSet : Set.S with type elt = location Utils.Marked.pos

Abstract syntax tree

Sourcetype typ =

| TLit of Dcalc.Ast.typ_lit
| TStruct of StructName.t
| TEnum of EnumName.t
| TArrow of typ Utils.Marked.pos * typ Utils.Marked.pos
| TArray of typ
| TAny

Sourcemodule Typ : Set.OrderedType with type t = typ

Sourcetype marked_expr = expr Utils.Marked.pos

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

Sourceand expr =

| ELocation of location
| EVar of expr Bindlib.var
| EStruct of StructName.t * marked_expr StructFieldMap.t
| EStructAccess of marked_expr * StructFieldName.t * StructName.t
| EEnumInj of marked_expr * EnumConstructor.t * EnumName.t
| EMatch of marked_expr * EnumName.t * marked_expr EnumConstructorMap.t
| ELit of Dcalc.Ast.lit
| EAbs of (expr, marked_expr) Bindlib.mbinder * typ Utils.Marked.pos list
| EApp of marked_expr * marked_expr list
| EOp of Dcalc.Ast.operator
| EDefault of marked_expr list * marked_expr * marked_expr
| EIfThenElse of marked_expr * marked_expr * marked_expr
| EArray of marked_expr list
| ErrorOnEmpty of marked_expr

Sourcemodule Expr : Set.OrderedType with type t = expr

Sourcemodule ExprMap : Map.S with type key = expr

Sourceval locations_used : expr Utils.Marked.pos -> LocationSet.t

Sourcetype io_input =

| NoInput
(*
For an internal variable defined only in the scope, and does not appear in the input.
*)
| OnlyInput
(*
For variables that should not be redefined in the scope, because they appear in the input.
*)
| Reentrant
(*
For variables defined in the scope that can also be redefined by the caller as they appear in the input.
*)

This type characterizes the three levels of visibility for a given scope variable with regards to the scope's input and possible redefinitions inside the scope..

Sourcetype io = {

io_output : bool Utils.Marked.pos;
(*
true is present in the output of the scope.
*)
io_input : io_input Utils.Marked.pos;

}

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

Sourcetype rule =

| Definition of location Utils.Marked.pos * typ Utils.Marked.pos * io * expr Utils.Marked.pos
| Assertion of expr Utils.Marked.pos
| Call of ScopeName.t * SubScopeName.t

Sourcetype scope_decl = {

scope_decl_name : ScopeName.t;
scope_sig : (typ Utils.Marked.pos * io) ScopeVarMap.t;
scope_decl_rules : rule list;

}

Sourcetype struct_ctx = (StructFieldName.t * typ Utils.Marked.pos) list StructMap.t

Sourcetype enum_ctx = (EnumConstructor.t * typ Utils.Marked.pos) list EnumMap.t

Sourcetype program = {

program_scopes : scope_decl ScopeMap.t;
program_enums : enum_ctx;
program_structs : struct_ctx;

}

Variable helpers

Sourcemodule Var : sig ... end

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

Sourcetype vars = expr Bindlib.mvar

Sourceval make_var : Var.t Utils.Marked.pos -> expr Utils.Marked.pos Bindlib.box

Source

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

Source

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

Source

val make_let_in : 
  Var.t ->
  typ Utils.Marked.pos ->
  expr Utils.Marked.pos Bindlib.box ->
  expr Utils.Marked.pos Bindlib.box ->
  expr Utils.Marked.pos Bindlib.box

Source

val make_default : 
  ?pos:Utils.Pos.t ->
  expr Utils.Marked.pos list ->
  expr Utils.Marked.pos ->
  expr Utils.Marked.pos ->
  expr Utils.Marked.pos

make_default ?pos exceptions just cons builds a term semantically equivalent to <exceptions | just :- cons> (the EDefault constructor) while avoiding redundant nested constructions. The position is extracted from just by default.

Note that, due to the simplifications taking place, the result might not be of the form EDefault:

<true :- x> is rewritten as x
<ex | true :- def>, when def is a default term <j :- c> without exceptions, is collapsed into <ex | def>
<ex | false :- _>, when ex is a single exception, is rewritten as ex