Module Frontend.Ast

Abstract syntax tree for Stan. Defined with the 'two-level types' pattern, where the variant types are not directly recursive, but rather parametric in some other type.

This type ends up being substituted for the fixpoint of the recursive type itself including metadata. So instead of recursively referencing expression you would instead reference type parameter 'e, which will later be filled in with something like type expr_with_meta = metadata expression

type identifier = {
  1. name : Core.string;
  2. id_loc : Middle.Location_span.t;
}

Our type for identifiers, on which we record a location

val sexp_of_identifier : identifier -> Sexplib0.Sexp.t
val compare_identifier : identifier -> identifier -> Core.int
type 'e index =
  1. | All
  2. | Single of 'e
  3. | Upfrom of 'e
  4. | Downfrom of 'e
  5. | Between of 'e * 'e

Indices for array access

val sexp_of_index : 'e. ('e -> Sexplib0.Sexp.t) -> 'e index -> Sexplib0.Sexp.t
val compare_index : 'e. ('e -> 'e -> Core.int) -> 'e index -> 'e index -> Core.int
val map_index : ('a -> 'b) -> 'a index -> 'b index
val fold_index : ('a -> 'b -> 'a) -> 'a -> 'b index -> 'a
type fun_kind =
  1. | StanLib of Core.bool Middle.Fun_kind.suffix
  2. | UserDefined of Core.bool Middle.Fun_kind.suffix

Front-end function kinds

val compare_fun_kind : fun_kind -> fun_kind -> Core.int
val sexp_of_fun_kind : fun_kind -> Sexplib0.Sexp.t
type ('e, 'f, 'p) expression =
  1. | TernaryIf of 'e * 'e * 'e
  2. | BinOp of 'e * Middle.Operator.t * 'e
  3. | PrefixOp of Middle.Operator.t * 'e
  4. | PostfixOp of 'e * Middle.Operator.t
  5. | Variable of identifier
  6. | IntNumeral of Core.string
  7. | RealNumeral of Core.string
  8. | ImagNumeral of Core.string
  9. | FunApp of 'f * identifier * 'e Core.list
  10. | CondDistApp of 'f * identifier * 'e Core.list
  11. | Promotion of 'e * 'p
  12. | GetTarget
  13. | ArrayExpr of 'e Core.list
  14. | RowVectorExpr of 'e Core.list
  15. | Paren of 'e
  16. | Indexed of 'e * 'e index Core.list
  17. | TupleProjection of 'e * Core.int
  18. | TupleExpr of 'e Core.list

Expression shapes (used for both typed and untyped expressions, where we substitute untyped_expression or typed_expression for 'e

val sexp_of_expression : 'e 'f 'p. ('e -> Sexplib0.Sexp.t) -> ('f -> Sexplib0.Sexp.t) -> ('p -> Sexplib0.Sexp.t) -> ('e, 'f, 'p) expression -> Sexplib0.Sexp.t
val compare_expression : 'e 'f 'p. ('e -> 'e -> Core.int) -> ('f -> 'f -> Core.int) -> ('p -> 'p -> Core.int) -> ('e, 'f, 'p) expression -> ('e, 'f, 'p) expression -> Core.int
type ('m, 'f, 'p) expr_with = {
  1. expr : (('m, 'f, 'p) expr_with, 'f, 'p) expression;
  2. emeta : 'm;
}
val sexp_of_expr_with : 'm 'f 'p. ('m -> Sexplib0.Sexp.t) -> ('f -> Sexplib0.Sexp.t) -> ('p -> Sexplib0.Sexp.t) -> ('m, 'f, 'p) expr_with -> Sexplib0.Sexp.t
val compare_expr_with : 'm 'f 'p. ('m -> 'm -> Core.int) -> ('f -> 'f -> Core.int) -> ('p -> 'p -> Core.int) -> ('m, 'f, 'p) expr_with -> ('m, 'f, 'p) expr_with -> Core.int
type located_meta = {
  1. loc : Middle.Location_span.t;
}

Untyped expressions, which have location_spans as meta-data

val sexp_of_located_meta : located_meta -> Sexplib0.Sexp.t
val compare_located_meta : located_meta -> located_meta -> Core.int
type untyped_expression = (located_meta, Core.unit, Core.Nothing.t) expr_with
val sexp_of_untyped_expression : untyped_expression -> Sexplib0.Sexp.t
val compare_untyped_expression : untyped_expression -> untyped_expression -> Core.int
type typed_expr_meta = {
  1. loc : Middle.Location_span.t;
  2. ad_level : Middle.UnsizedType.autodifftype;
  3. type_ : Middle.UnsizedType.t;
}

Typed expressions also have meta-data after type checking: a location_span, as well as a type and an origin block (lub of the origin blocks of the identifiers in it)

val sexp_of_typed_expr_meta : typed_expr_meta -> Sexplib0.Sexp.t
val sexp_of_typed_expression : typed_expression -> Sexplib0.Sexp.t
val expr_loc_lub : (typed_expr_meta, 'a, 'b) expr_with Core.List.t -> Middle.Location_span.t
val expr_ad_lub : (typed_expr_meta, 'a, 'b) expr_with Core.List.t -> Middle.UnsizedType.autodifftype option

Least upper bound of expression autodiff types

type assignmentoperator =
  1. | Assign
  2. | OperatorAssign of Middle.Operator.t

Assignment operators

val sexp_of_assignmentoperator : assignmentoperator -> Sexplib0.Sexp.t
val compare_assignmentoperator : assignmentoperator -> assignmentoperator -> Core.int
type 'e truncation =
  1. | NoTruncate
  2. | TruncateUpFrom of 'e
  3. | TruncateDownFrom of 'e
  4. | TruncateBetween of 'e * 'e

Truncations

val sexp_of_truncation : 'e. ('e -> Sexplib0.Sexp.t) -> 'e truncation -> Sexplib0.Sexp.t
val compare_truncation : 'e. ('e -> 'e -> Core.int) -> 'e truncation -> 'e truncation -> Core.int
val map_truncation : ('a -> 'b) -> 'a truncation -> 'b truncation
val fold_truncation : ('a -> 'b -> 'a) -> 'a -> 'b truncation -> 'a
type 'e printable =
  1. | PString of Core.string
  2. | PExpr of 'e

Things that can be printed

val sexp_of_printable : 'e. ('e -> Sexplib0.Sexp.t) -> 'e printable -> Sexplib0.Sexp.t
val compare_printable : 'e. ('e -> 'e -> Core.int) -> 'e printable -> 'e printable -> Core.int
val map_printable : ('a -> 'b) -> 'a printable -> 'b printable
val fold_printable : ('a -> 'b -> 'a) -> 'a -> 'b printable -> 'a
type ('l, 'e) lvalue =
  1. | LVariable of identifier
  2. | LIndexed of 'l * 'e index Core.list
  3. | LTupleProjection of 'l * Core.int
val sexp_of_lvalue : 'l 'e. ('l -> Sexplib0.Sexp.t) -> ('e -> Sexplib0.Sexp.t) -> ('l, 'e) lvalue -> Sexplib0.Sexp.t
val compare_lvalue : 'l 'e. ('l -> 'l -> Core.int) -> ('e -> 'e -> Core.int) -> ('l, 'e) lvalue -> ('l, 'e) lvalue -> Core.int
val map_lvalue : ('a -> 'b) -> ('c -> 'd) -> ('a, 'c) lvalue -> ('b, 'd) lvalue
val fold_lvalue : ('a -> 'b -> 'a) -> ('a -> 'c -> 'a) -> 'a -> ('b, 'c) lvalue -> 'a
type 'l lvalue_pack =
  1. | LValue of 'l
  2. | LTuplePack of {
    1. lvals : 'l lvalue_pack Core.list;
    2. loc : Middle.Location_span.t;
    }
val sexp_of_lvalue_pack : 'l. ('l -> Sexplib0.Sexp.t) -> 'l lvalue_pack -> Sexplib0.Sexp.t
val compare_lvalue_pack : 'l. ('l -> 'l -> Core.int) -> 'l lvalue_pack -> 'l lvalue_pack -> Core.int
val map_lvalue_pack : ('a -> 'b) -> 'a lvalue_pack -> 'b lvalue_pack
val fold_lvalue_pack : ('a -> 'b -> 'a) -> 'a -> 'b lvalue_pack -> 'a
type ('e, 'm) lval_with = {
  1. lval : (('e, 'm) lval_with, 'e) lvalue;
  2. lmeta : 'm;
}
val sexp_of_lval_with : 'e 'm. ('e -> Sexplib0.Sexp.t) -> ('m -> Sexplib0.Sexp.t) -> ('e, 'm) lval_with -> Sexplib0.Sexp.t
val compare_lval_with : 'e 'm. ('e -> 'e -> Core.int) -> ('m -> 'm -> Core.int) -> ('e, 'm) lval_with -> ('e, 'm) lval_with -> Core.int
val sexp_of_untyped_lval : untyped_lval -> Sexplib0.Sexp.t
val compare_untyped_lval : untyped_lval -> untyped_lval -> Core.int
val map_untyped_lval : 'a -> 'a
val fold_untyped_lval : 'a -> 'b -> 'a
type untyped_lval_pack = untyped_lval lvalue_pack
val sexp_of_untyped_lval_pack : untyped_lval_pack -> Sexplib0.Sexp.t
val compare_untyped_lval_pack : untyped_lval_pack -> untyped_lval_pack -> Core.int
val sexp_of_typed_lval : typed_lval -> Sexplib0.Sexp.t
val map_typed_lval : 'a -> 'a
val fold_typed_lval : 'a -> 'b -> 'a
type typed_lval_pack = typed_lval lvalue_pack
val sexp_of_typed_lval_pack : typed_lval_pack -> Sexplib0.Sexp.t
type 'e variable = {
  1. identifier : identifier;
  2. initial_value : 'e Core.option;
}
val sexp_of_variable : 'e. ('e -> Sexplib0.Sexp.t) -> 'e variable -> Sexplib0.Sexp.t
val compare_variable : 'e. ('e -> 'e -> Core.int) -> 'e variable -> 'e variable -> Core.int
val map_variable : ('e -> 'a) -> 'e variable -> 'a variable
val fold_variable : ('a -> 'b -> 'a) -> 'a -> 'b variable -> 'a
type ('e, 's, 'l, 'f) statement =
  1. | Assignment of {
    1. assign_lhs : 'l lvalue_pack;
    2. assign_op : assignmentoperator;
    3. assign_rhs : 'e;
    }
  2. | NRFunApp of 'f * identifier * 'e Core.list
  3. | TargetPE of 'e
  4. | JacobianPE of 'e
  5. | Tilde of {
    1. arg : 'e;
    2. distribution : identifier;
    3. kind : 'f;
    4. args : 'e Core.list;
    5. truncation : 'e truncation;
    }
  6. | Break
  7. | Continue
  8. | Return of 'e
  9. | ReturnVoid
  10. | Print of 'e printable Core.list
  11. | Reject of 'e printable Core.list
  12. | FatalError of 'e printable Core.list
  13. | Skip
  14. | IfThenElse of 'e * 's * 's Core.option
  15. | While of 'e * 's
  16. | For of {
    1. loop_variable : identifier;
    2. lower_bound : 'e;
    3. upper_bound : 'e;
    4. loop_body : 's;
    }
  17. | ForEach of identifier * 'e * 's
  18. | Profile of Core.string * 's Core.list
  19. | Block of 's Core.list
  20. | VarDecl of {
    1. decl_type : 'e Middle.SizedType.t;
    2. transformation : 'e Middle.Transformation.t;
    3. is_global : Core.bool;
    4. variables : 'e variable Core.list;
    }
  21. | FunDef of {
    1. returntype : Middle.UnsizedType.returntype;
    2. funname : identifier;
    3. arguments : (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t * identifier) Core.list;
    4. body : 's;
    }

Statement shapes, where we substitute untyped_expression and untyped_statement for 'e and 's respectively to get untyped_statement and typed_expression and typed_statement to get typed_statement

val sexp_of_statement : 'e 's 'l 'f. ('e -> Sexplib0.Sexp.t) -> ('s -> Sexplib0.Sexp.t) -> ('l -> Sexplib0.Sexp.t) -> ('f -> Sexplib0.Sexp.t) -> ('e, 's, 'l, 'f) statement -> Sexplib0.Sexp.t
val compare_statement : 'e 's 'l 'f. ('e -> 'e -> Core.int) -> ('s -> 's -> Core.int) -> ('l -> 'l -> Core.int) -> ('f -> 'f -> Core.int) -> ('e, 's, 'l, 'f) statement -> ('e, 's, 'l, 'f) statement -> Core.int
type statement_returntype =
  1. | Incomplete
  2. | NonlocalControlFlow
  3. | Complete

Statement return types which we will decorate statements with during type checking:

  • Complete corresponds to statements that exit the function (return or error) in every branch
  • Incomplete corresponds to statements which pass control flow to following statements in at least some branches
  • NonlocalControlFlow is simila to Incomplete but specifically used when breaks are present in loops. Normally, an infinite loop with Incomplete return type is fine (and considered Complete), since it either returns or diverges. However, in the presence of break statements, control flow may jump to the end of the loop.
val sexp_of_statement_returntype : statement_returntype -> Sexplib0.Sexp.t
type ('e, 'm, 'l, 'f) statement_with = {
  1. stmt : ('e, ('e, 'm, 'l, 'f) statement_with, 'l, 'f) statement;
  2. smeta : 'm;
}
val sexp_of_statement_with : 'e 'm 'l 'f. ('e -> Sexplib0.Sexp.t) -> ('m -> Sexplib0.Sexp.t) -> ('l -> Sexplib0.Sexp.t) -> ('f -> Sexplib0.Sexp.t) -> ('e, 'm, 'l, 'f) statement_with -> Sexplib0.Sexp.t
val compare_statement_with : 'e 'm 'l 'f. ('e -> 'e -> Core.int) -> ('m -> 'm -> Core.int) -> ('l -> 'l -> Core.int) -> ('f -> 'f -> Core.int) -> ('e, 'm, 'l, 'f) statement_with -> ('e, 'm, 'l, 'f) statement_with -> Core.int

Untyped statements, which have location_spans as meta-data

val sexp_of_untyped_statement : untyped_statement -> Sexplib0.Sexp.t
val compare_untyped_statement : untyped_statement -> untyped_statement -> Core.int
type stmt_typed_located_meta = {
  1. loc : Middle.Location_span.t;
  2. return_type : statement_returntype;
}
val sexp_of_stmt_typed_located_meta : stmt_typed_located_meta -> Sexplib0.Sexp.t

Typed statements also have meta-data after type checking: a location_span, as well as a statement returntype to check that function bodies have the right return type

val sexp_of_typed_statement : typed_statement -> Sexplib0.Sexp.t
val mk_typed_statement : stmt: ('a, ('a, stmt_typed_located_meta, 'b, 'c) statement_with, 'b, 'c) statement -> loc:Middle.Location_span.t -> return_type:statement_returntype -> ('a, stmt_typed_located_meta, 'b, 'c) statement_with
type 's block = {
  1. stmts : 's Core.list;
  2. xloc : Middle.Location_span.t;
}

Program shapes, where we obtain types of programs if we substitute typed or untyped statements for 's

val sexp_of_block : 's. ('s -> Sexplib0.Sexp.t) -> 's block -> Sexplib0.Sexp.t
val compare_block : 's. ('s -> 's -> Core.int) -> 's block -> 's block -> Core.int
val map_block : ('s -> 'a) -> 's block -> 'a block
val fold_block : ('a -> 'b -> 'a) -> 'a -> 'b block -> 'a
type comment_type =
  1. | LineComment of Core.string * Middle.Location_span.t
  2. | Include of Core.string * Middle.Location_span.t
  3. | BlockComment of Core.string Core.list * Middle.Location_span.t
  4. | Separator of Middle.Location.t
    (*

    Separator records the location of items like commas, operators, and keywords which don't have location information stored in the AST but are useful for placing comments in pretty printing

    *)
type 's program = {
  1. functionblock : 's block Core.option;
  2. datablock : 's block Core.option;
  3. transformeddatablock : 's block Core.option;
  4. parametersblock : 's block Core.option;
  5. transformedparametersblock : 's block Core.option;
  6. modelblock : 's block Core.option;
  7. generatedquantitiesblock : 's block Core.option;
  8. comments : comment_type Core.list;
}
val sexp_of_program : 's. ('s -> Sexplib0.Sexp.t) -> 's program -> Sexplib0.Sexp.t
val compare_program : 's. ('s -> 's -> Core.int) -> 's program -> 's program -> Core.int
val map_program : ('s -> 'a) -> 's program -> 'a program
val fold_program : ('a -> 'b -> 'a) -> 'a -> 'b program -> 'a
val get_stmts : 'a block Core.Option.t -> 'a Core.list
type untyped_program = untyped_statement program

Untyped programs (before type checking)

val sexp_of_untyped_program : untyped_program -> Sexplib0.Sexp.t
val compare_untyped_program : untyped_program -> untyped_program -> Core.int
type typed_program = typed_statement program

Typed programs (after type checking)

val sexp_of_typed_program : typed_program -> Sexplib0.Sexp.t
val untyped_expression_of_typed_expression : typed_expression -> untyped_expression

Forgetful function from typed to untyped expressions

val untyped_lvalue_of_typed_lvalue : typed_lval -> untyped_lval
val untyped_lvalue_of_typed_lvalue_pack : typed_lval lvalue_pack -> untyped_lval lvalue_pack

Forgetful function from typed to untyped statements

val untyped_program_of_typed_program : typed_program -> untyped_program

Forgetful function from typed to untyped programs

in practice, we never want to fold over the FnKind or Promotion types so we shadow the @@derived fold_expression

val fold_expression : ('a -> 'b -> 'a) -> 'a -> ('b, 'c, 'd) expression -> 'a
val fold_lval_with : ('a -> 'b -> 'a) -> 'a -> ('b, 'c) lval_with -> 'a
val fold_statement : ('a -> 'b -> 'a) -> ('a -> 'c -> 'a) -> ('a -> 'd -> 'a) -> 'a -> ('b, 'c, 'd, 'e) statement -> 'a

similarly for map

val map_expression : ('a -> 'b) -> ('a, 'c, 'd) expression -> ('b, 'c, 'd) expression
val map_lval_with : ('a -> 'b) -> ('a, 'c) lval_with -> ('b, 'c) lval_with
val map_statement : ('a -> 'b) -> ('c -> 'd) -> ('e -> 'f) -> ('a, 'c, 'e, 'g) statement -> ('b, 'd, 'f, 'g) statement
val mk_typed_expression : expr:((typed_expr_meta, 'a, 'b) expr_with, 'a, 'b) expression -> loc:Middle.Location_span.t -> type_:Middle.UnsizedType.t -> ad_level:Middle.UnsizedType.autodifftype -> (typed_expr_meta, 'a, 'b) expr_with
val expr_of_lvalue : (('a, 'b, 'c) expr_with, 'a) lval_with -> ('a, 'b, 'c) expr_with
val exprs_in_index : 'a index -> 'a list
val extract_ids : ('a, 'b, 'c) expr_with -> identifier Core.List.t
val lvalue_of_expr_opt : untyped_expression -> ((located_meta, Core.unit, Core.Nothing.t) expr_with, located_meta) lval_with lvalue_pack Core.Option.t
val get_loc_lvalue_pack : typed_lval lvalue_pack -> Middle.Location_span.t
val get_first_loc : untyped_statement -> Middle.Location.t