Contains some structures used for type inference

The generic type of AST markings. Using a GADT allows functions to be polymorphic in the marking, but still do transformations on types when appropriate

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

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.

This type is parametrized by the expression type so it can be reused in later intermediate representations.

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.

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. The first binder is the argument of type scope_body_input_struct.

Finally, we do the same transformation for the whole program for the kinded lets. This permit us to use bindlib variables for scopes names.

If you want to apply a map transform to an expression, you can save up writing a painful match over all the cases of the AST. For instance, if you want to remove all errors on empty, you can write

  let remove_error_empty =
    let rec f () e =
      match Marked.unmark e with
      | ErrorOnEmpty e1 -> map_expr () f e1
      | _ -> map_expr () f e
    in
    f () e

The first argument of map_expr is an optional context that you can carry around during your map traversal.

Recursively applies f to the nodes of the expression tree. The type returned by f is hybrid since the mark at top-level has been rewritten, but not yet the marks in the subtrees.

Usage: fold_left_scope_lets ~f:(fun acc scope_let scope_let_var -> ...) ~init scope_lets, where scope_let_var is the variable bound to the scope let in the next scope lets to be examined.

Usage: fold_right_scope_lets ~f:(fun scope_let scope_let_var acc -> ...) ~init scope_lets, where scope_let_var is the variable bound to the scope let in the next scope lets to be examined (which are before in the program order).

Usage: fold_left_scope_defs ~f:(fun acc scope_def scope_var -> ...) ~init scope_def, where scope_var is the variable bound to the scope in the next scopes to be examined.

Usage: fold_right_scope_defs ~f:(fun scope_def scope_var acc -> ...) ~init scope_def, where scope_var is the variable bound to the scope in the next scopes to be examined (which are before in the program order).

This is the main map visitor for all the expressions inside all the scopes of the program.

used to convert between e.g. untyped expr var into a typed expr var

Determines if two expressions are equal, omitting their position information

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

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

Used by the optimizer to know when to stop

Removes all calls to Log unary operators in the AST, replacing them by their argument.

build_scope_typ_from_sig ctx in_struct out_struct pos builds the arrow type for the specified scope