+
+ OCaml package documentation
+-
+
- stanc +
Analysis_and_optimization.Dataflow_typesA label is a unique identifier for a node in the dataflow/dependency graph, and often corresponds to one node in the Mir.
val label_of_sexp : Sexplib0.Sexp.t -> labelval sexp_of_label : label -> Sexplib0.Sexp.tval hash_fold_label :
+ Ppx_hash_lib.Std.Hash.state ->
+ label ->
+ Ppx_hash_lib.Std.Hash.stateval hash_label : label -> Ppx_hash_lib.Std.Hash.hash_valueRepresentation of an expression that can be assigned to. This should also be able to represent indexed variables, but we don't support that yet.
val vexpr_of_sexp : Sexplib0.Sexp.t -> vexprval sexp_of_vexpr : vexpr -> Sexplib0.Sexp.tval hash_fold_vexpr :
+ Ppx_hash_lib.Std.Hash.state ->
+ vexpr ->
+ Ppx_hash_lib.Std.Hash.stateval hash_vexpr : vexpr -> Ppx_hash_lib.Std.Hash.hash_valueA 'reaching definition' (or reaching_defn or RD) statement (v, l) says that the variable v could have been affected at the label l.
val reaching_defn_of_sexp : Sexplib0.Sexp.t -> reaching_defnval sexp_of_reaching_defn : reaching_defn -> Sexplib0.Sexp.tval hash_fold_reaching_defn :
+ Ppx_hash_lib.Std.Hash.state ->
+ reaching_defn ->
+ Ppx_hash_lib.Std.Hash.stateval hash_reaching_defn : reaching_defn -> Ppx_hash_lib.Std.Hash.hash_valueval compare_reaching_defn : reaching_defn -> reaching_defn -> inttype source_loc = | MirNode of Middle.Location_span.t| StartOfBlock| TargetTerm of {term : Middle.Expr.Typed.t;assignment_label : label;}Description of where a node in the dependency graph came from, where MirNode is the location from an Middle.loc_stmt
val source_loc_of_sexp : Sexplib0.Sexp.t -> source_locval sexp_of_source_loc : source_loc -> Sexplib0.Sexp.ttype 'rd_info node_info = {rd_sets : 'rd_info;possible_previous : label Core.Set.Poly.t;rhs_set : vexpr Core.Set.Poly.t;controlflow : label Core.Set.Poly.t;loc : source_loc;}Information to be collected about each node * rd_sets: Information about how the label effects the reaching definition sets * possible_previous: The set of nodes that could have immediately preceded this node under some execution of the program * rhs_set: The 'right hand side' set of variables that affect the value or behavior of this node * controlflow: The set of control flow nodes that are immediate parents of this node: * The most recent nested if/then or loop, * or the beginning of the function or block if there are no containing branches, * plus the set of relevant continue/return statements, * plus, for loops, any break statements they contain * loc: The location of the Mir node that this node corresponds to, or a description if there is none
val node_info_of_sexp :
+ 'rd_info. (Sexplib0.Sexp.t -> 'rd_info) ->
+ Sexplib0.Sexp.t ->
+ 'rd_info node_infoval sexp_of_node_info :
+ 'rd_info. ('rd_info -> Sexplib0.Sexp.t) ->
+ 'rd_info node_info ->
+ Sexplib0.Sexp.ttype node_info_update =
+ (reaching_defn Core.Set.Poly.t -> reaching_defn Core.Set.Poly.t) node_infoA node_info, where the reaching definition information takes the form of an update function that maps from the 'entry' set to the 'exit' set, where the entry set is what's true before executing this node and the exit set is true after.
type node_info_fixedpoint =
+ (reaching_defn Core.Set.Poly.t * reaching_defn Core.Set.Poly.t) node_infoA node_info where the reaching definition information is explicitly written as the entry and exit sets, as after finding the fixed-point solution.
val node_info_fixedpoint_of_sexp : Sexplib0.Sexp.t -> node_info_fixedpointval sexp_of_node_info_fixedpoint : node_info_fixedpoint -> Sexplib0.Sexp.ttype traversal_state = {label_ix : label;node_info_map : (int, node_info_update) Core.Map.Poly.t;possible_previous : label Core.Set.Poly.t;target_terms : label Core.Set.Poly.t;continues : label Core.Set.Poly.t;breaks : label Core.Set.Poly.t;returns : label Core.Set.Poly.t;rejects : label Core.Set.Poly.t;}The state that will be maintained throughout the traversal of the Mir * label_ix: The next label that's free to use * node_info_map: The label information that's been built so far * possible_previous: The set of nodes that could have immediately preceded this point under some execution of the program * target_terms: The set of nodes that correspond to terms added to the target variable * continues: A set of the continue nodes that have been encountered since exiting a loop * breaks: A set of the break nodes that have been encountered since exiting a loop * returns: A set of the return nodes that have been encountered
type cf_state = labelThe most recently nested control flow (block start, if/then, or loop)
This isn't included in the traversal_state because it only flows downward through the tree, not across and up like everything else
type dataflow_graph = {node_info_map : (int, node_info_fixedpoint) Core.Map.Poly.t;possible_exits : label Core.Set.Poly.t;probabilistic_nodes : label Core.Set.Poly.t;}Everything we need to know to do dependency analysis * node_info_map: Collection of node information * possible_exits: Set of nodes that could be the last to execute under some execution * probabilistic_nodes: Set of nodes corresponding to which can only introduce probabilistic dependencies, such as target terms and reject statements, to be excluded for non-statistical dependency analysis
val dataflow_graph_of_sexp : Sexplib0.Sexp.t -> dataflow_graphval sexp_of_dataflow_graph : dataflow_graph -> Sexplib0.Sexp.tRepresents the dataflow graphs for each interesting block in the program MIR.
See Middle.prog for block descriptions.
val prog_df_graphs_of_sexp : Sexplib0.Sexp.t -> prog_df_graphsval sexp_of_prog_df_graphs : prog_df_graphs -> Sexplib0.Sexp.tAnalysis_and_optimization.Dataflow_utilsval union_maps_left :
+ ('a, 'b) Core.Map.Poly.t ->
+ ('a, 'b) Core.Map.Poly.t ->
+ ('a, 'b) Core.Map.Poly.tUnion maps, preserving the left element in a collision
val build_cf_graphs :
+ ?flatten_loops:bool ->
+ ?blocks_after_body:bool ->
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * 'm)
+ Core.Map.Poly.t ->
+ Dataflow_types.label Core.Set.Poly.t
+ * (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t)
+ Core.Map.Poly.t
+ * (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t)
+ Core.Map.Poly.tSimultaneously builds the controlflow parent graph, the predecessor graph and the exit set of a statement. It's advantageous to build them together because they both rely on some of the same Break, Continue and Return bookkeeping.
Takes a statement map and returns the triple: (exit set, predecessor graph, controlflow parent graph) where * (exit set, predecessor graph) is the return value of build_predecessor_graph * (controlflow parent graph) is the return value of build_cf_graph
val build_cf_graph :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * 'm)
+ Core.Map.Poly.t ->
+ (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t) Core.Map.Poly.tBuilding the controlflow graph requires a traversal with state that includes continues, breaks, returns and the controlflow graph accumulator. The traversal should be a branching traversal with set unions rather than a forward traversal because continue and return statements shouldn't affect other branches of execution.
val build_predecessor_graph :
+ ?flatten_loops:bool ->
+ ?blocks_after_body:bool ->
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * 'm)
+ Core.Map.Poly.t ->
+ Dataflow_types.label Core.Set.Poly.t
+ * (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t)
+ Core.Map.Poly.tBuilding the predecessor graph requires a traversal with state that includes the current previous nodes and the predecessor graph accumulator. Special cases are made for loops, because they should include the body exits as predecessors to the body, and they should include loop predecessors in their exit sets. I'm not sure if the single re-traversal of the loop body is sufficient or this requires finding a fixed-point.
val build_recursive_statement :
+ (('e, 's) Middle.Stmt.Fixed.Pattern.t -> 'm -> 's) ->
+ (Dataflow_types.label,
+ ('e, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t * 'm)
+ Core.Map.Poly.t ->
+ Dataflow_types.label ->
+ 'sBuild a fixed-point data type representation of a statement given a label-map representation.
val is_ctrl_flow : ('a, 'b) Middle.Stmt.Fixed.Pattern.t -> boolCheck if the statement controls the execution of its substatements.
val merge_set_maps :
+ ('a, 'b Core.Set.Poly.t) Core.Map.Poly.t ->
+ ('a, 'b Core.Set.Poly.t) Core.Map.Poly.t ->
+ ('a, 'b Core.Set.Poly.t) Core.Map.Poly.tMerge two maps whose values are sets, and union the sets when there's a collision.
Generate a Map by applying a function to each element of a key set.
val build_statement_map :
+ ('s -> ('e, 's) Middle.Stmt.Fixed.Pattern.t) ->
+ ('s -> 'm) ->
+ 's ->
+ (Dataflow_types.label,
+ ('e, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t * 'm)
+ Core.Map.Poly.tThe statement map is built by traversing substatements recursively to replace substatements with their labels while building up the substatements' statement maps. Then, the result is the union of the substatement maps with this statement's singleton pair, which is expressed in terms of the new label-containing statement.
Analysis_and_optimization.Debug_data_generationval json_to_mir :
+ (Middle.Expr.Typed.t Middle.SizedType.t * 'a * string) list ->
+ Yojson.Basic.t ->
+ (string, Middle.Expr.Typed.t) Core.Map.Poly.tTranslates Yojson object into a data type that `gen_values_json` understands.
val gen_values_json :
+ ?new_only:bool ->
+ ?context:(string, Middle.Expr.Typed.t) Core.Map.Poly.t ->
+ (Middle.Expr.Typed.t Middle.SizedType.t
+ * Middle.Expr.Typed.t Middle.Transformation.t
+ * string)
+ list ->
+ (string, Middle.Location_span.t * string) Core.resultGenerates values matching the given declarations and formats them as a JSON string. The declarations may depend on additional values supplied in `context`. If `new_only` is true (defaults to false) the output does not include the values in `context`
Analysis_and_optimization.Dependence_analysis~~~~~ TODO ~~~~~ * The interfaces are currently messed up. I think part of the solution is to change the signature of reaching_definitions_mfp in Monotone_framework, which currently requires the full program but shouldn't need the full program. As it stands, stmt_map_dependency_graph does not include data dependencies at all, since it can't use reaching deps, and prog_dependency graph only builds the graph for log_prob, but the user isn't guaranteed to be using the same labeling scheme. * Currently, dependencies on global or uninitialized data are written as depending on node '0'. This should probably be option or some type that indicates global dependence. * Indexed variables are currently handled as monoliths * No probabilistic dependency, I'll do that elsewhere *
type node_dep_info = {predecessors : Dataflow_types.label Core.Set.Poly.t;parents : Dataflow_types.label Core.Set.Poly.t;reaching_defn_entry : Dataflow_types.reaching_defn Core.Set.Poly.t;reaching_defn_exit : Dataflow_types.reaching_defn Core.Set.Poly.t;meta : Middle.Location_span.t;}Sufficient information about each node to build the dependency graph.
Label dependence doesn't need the exit RD set, but variable dependence does.
val node_immediate_dependencies :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.t ->
+ ?blockers:Dataflow_types.vexpr Core.Set.Poly.t ->
+ Dataflow_types.label ->
+ Dataflow_types.label Core.Set.Poly.tGiven dependency information for each node, find the 'immediate' dependencies of a node, where 'immediate' means the first-degree control flow parents and the reachable definitions of RHS variables.
val node_dependencies :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.t ->
+ Dataflow_types.label ->
+ Dataflow_types.label Core.Set.Poly.tGiven dependency information for each node, find all of the dependencies of a single node.
val node_vars_dependencies :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.t ->
+ ?blockers:Dataflow_types.vexpr Core.Set.Poly.t ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ Dataflow_types.label ->
+ Dataflow_types.label Core.Set.Poly.tGiven dependency information for each node, find all of the dependencies of a set of variables at single node.
'blockers' are variables which will not be traversed.
val build_dep_info_map :
+ Middle.Program.Typed.t ->
+ Middle.Stmt.Located.t ->
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.tBuild the dependency information for each node in the log_prob section of a program
val log_prob_build_dep_info_map :
+ Middle.Program.Typed.t ->
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.tBuild the dependency information for each node in the log_prob section of a program
val all_node_dependencies :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * node_dep_info)
+ Core.Map.Poly.t ->
+ (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t) Core.Map.Poly.tGiven dependency information for each node, find all of the dependencies of all nodes, effectively building the dependency graph.
This is more efficient than calling node_dependencies on each node individually.
val log_prob_dependency_graph :
+ Middle.Program.Typed.t ->
+ (Dataflow_types.label, Dataflow_types.label Core.Set.Poly.t) Core.Map.Poly.tBuild the dependency graph for the log_prob section of a program, where labels correspond to the labels built by statement_map.
val reaching_defn_lookup :
+ Dataflow_types.reaching_defn Core.Set.Poly.t ->
+ Dataflow_types.vexpr ->
+ Dataflow_types.label Core.Set.Poly.tval mir_uninitialized_variables :
+ Middle.Program.Typed.t ->
+ (Middle.Location_span.t * string) Core.Set.Poly.tProduce a list of uninitialized variables and their label locations, from the flowgraph starting at the given statement
Analysis_and_optimization.Factor_graphtype factor = | TargetTerm of Middle.Expr.Typed.t| Reject| LPFunction of string * Middle.Expr.Typed.t listval factor_of_sexp : Sexplib0.Sexp.t -> factorval sexp_of_factor : factor -> Sexplib0.Sexp.tval hash_fold_factor :
+ Ppx_hash_lib.Std.Hash.state ->
+ factor ->
+ Ppx_hash_lib.Std.Hash.stateval hash_factor : factor -> Ppx_hash_lib.Std.Hash.hash_valuetype factor_graph = {factor_map : (factor * Dataflow_types.label,
+ Dataflow_types.vexpr Core.Set.Poly.t)
+ Core.Map.Poly.t;var_map : (Dataflow_types.vexpr,
+ (factor * Dataflow_types.label) Core.Set.Poly.t)
+ Core.Map.Poly.t;}val factor_graph_of_sexp : Sexplib0.Sexp.t -> factor_graphval sexp_of_factor_graph : factor_graph -> Sexplib0.Sexp.tval compare_factor_graph : factor_graph -> factor_graph -> intval extract_factors_statement :
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ factor listval extract_factors :
+ ('a, (Middle.Expr.Typed.t, 'b) Middle.Stmt.Fixed.Pattern.t * 'c)
+ Core.Map.Poly.t ->
+ 'd ->
+ ('e * factor) listval factor_rhs : factor -> Dataflow_types.vexpr Core.Set.Poly.tval factor_var_dependencies :
+ (Dataflow_types.label,
+ (Middle.Expr.Typed.t, Dataflow_types.label) Middle.Stmt.Fixed.Pattern.t
+ * Dependence_analysis.node_dep_info)
+ Core.Map.Poly.t ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ (Dataflow_types.label * factor) ->
+ (Dataflow_types.vexpr, Core__.Comparator.Poly.comparator_witness) Core.Set.tval build_adjacency_maps :
+ (Dataflow_types.label * factor * Dataflow_types.vexpr Core.Set.Poly.t)
+ Core.List.t ->
+ factor_graphHelper function to generate the factor graph adjacency map representation from a factor-adjacency list
val fg_remove_fac :
+ (factor * Dataflow_types.cf_state) ->
+ factor_graph ->
+ factor_graphval fg_remove_var : Dataflow_types.vexpr -> factor_graph -> factor_graphval remove_touching :
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ factor_graph ->
+ factor_graphval prog_factor_graph :
+ ?exclude_data_facs:bool ->
+ Middle.Program.Typed.t ->
+ factor_graphBuild a factor graph from prog.log_prob using dependency analysis
val fg_reaches :
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ factor_graph ->
+ boolBFS on 'fg' with initial frontier 'starts' and terminating at any element of 'goals'
val fg_factor_reaches :
+ (factor * Dataflow_types.label) ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ factor_graph ->
+ boolval fg_factor_is_prior :
+ Dataflow_types.vexpr ->
+ (factor * Dataflow_types.label) ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ factor_graph ->
+ boolval fg_var_priors :
+ Dataflow_types.vexpr ->
+ Dataflow_types.vexpr Core.Set.Poly.t ->
+ factor_graph ->
+ (factor * Dataflow_types.label) Core.Set.Poly.t optionPriors of V are neighbors of V which have no connection to any data except though V So for graph G and each parameter V: G' = G\V; For each neighbor F: Use BFS starting from F in G' and search for any data, if there is none, F is a prior
val list_priors :
+ ?factor_graph:factor_graph option ->
+ Middle.Program.Typed.t ->
+ (Dataflow_types.vexpr,
+ (factor * Dataflow_types.label) Core.Set.Poly.t option)
+ Core.Map.Poly.tval string_of_factor : factor -> stringval string_of_vexpr : Dataflow_types.vexpr -> stringval factor_graph_to_dot : factor_graph -> stringUtility to print a factor graph to the Graphviz dot language for visualization
Analysis_and_optimization.Memory_patternsval matrix_set :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t ->
+ (Dataflow_types.vexpr * Middle.Expr.Typed.Meta.t) Core.Set.Poly.tReturn a Var expression of the name for each type containing an eigen matrix
val query_var_eigen_names : Middle.Expr.Typed.t -> string Core.Set.Poly.tReturn a set of all types containing autodiffable Eigen matrices in an expression.
Check whether one set is a nonzero subset of another set.
val count_single_idx : int -> Middle.Expr.Typed.t Middle.Index.t -> intCheck an Index to count how many times we see a single index.
val is_uni_eigen_loop_indexing :
+ bool ->
+ Middle.UnsizedType.t ->
+ Middle.Expr.Typed.t Middle.Index.t list ->
+ boolFind indices on Matrix and Vector types that perform single cell access. Returns true if it finds a vector, row vector, matrix, or matrix with single cell access as well as an array of any of the above that is accessing the inner matrix types cell.
val query_stan_math_mem_pattern_support :
+ string ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ boolval is_fun_soa_supported : string -> Middle.Expr.Typed.t list -> boolval query_initial_demotable_expr :
+ bool ->
+ acc:string Core.Set.Poly.t ->
+ Middle.Expr.Typed.t ->
+ string Core.Set.Poly.tQuery to find the initial set of objects that cannot be SoA. This is mostly recursing over expressions, with the exceptions being functions and indexing expressions. For the logic on functions see the docs for query_initial_demotable_funs.
val query_initial_demotable_funs :
+ bool ->
+ string Core.Set.Poly.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Fun_kind.t ->
+ Middle.Expr.Typed.t list ->
+ string Core.Set.Poly.tQuery a function to detect if it or any of its used expression's objects or expressions should be demoted to AoS. * The logic here demotes the expressions in a function to AoS if the function's inner expression returns has a meta type containing a matrix and either of : (1) The function is user defined and the UDFs inputs are matrices. (2) The Stan math function cannot support AoS
val extract_nonderived_admatrix_types :
+ Middle.Expr.Typed.t ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list* Recurse through subexpressions and return a list of Unsized types. * Recursion continues until * 1. A non-autodiffable type is found * 2. An autodiffable scalar is found * 3. A `Var` type is found that is an autodiffable matrix
val extract_nonderived_admatrix_types_fun :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Fun_kind.t ->
+ Middle.Expr.Typed.t list ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list* Recurse through functions to find nonderived ad matrix types. * Special cases for StanLib functions are for * - `check_matching_dims`: compiler function that has no effect on optimization * - `rep_*vector` These are templated in the C++ to cast up to `Var<Matrix>` types * - `rep_matrix`. When it's only a scalar being propogated an math library overload can upcast to `Var<Matrix>`
val contains_at_least_one_ad_matrix_or_all_data :
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ boolChecks if a list of types contains at least on ad matrix or if everything is derived from data
val query_initial_demotable_stmt :
+ bool ->
+ string Core.Set.Poly.t ->
+ (Middle.Expr.Typed.Meta.t, Middle.Stmt.Located.Meta.t) Middle.Stmt.Fixed.t ->
+ string Core.Set.Poly.tQuery to find the initial set of objects in statements that cannot be SoA. This is mostly recursive over expressions and statements, with the exception of functions and Assignments. * For assignments: We demote the LHS variable if any of the following are true: 1. A single cell of the LHS is being assigned within a loop. 2. The top level expression on the RHS is a combination of only data matrices and scalar types. Operations on data matrix and scalar values in Stan math will return a AoS matrix. We currently have no way to tell Stan math to return a SoA matrix. 3. None of the RHS's functions are able to accept SoA matrices and the rhs is not an internal compiler function. * We demote RHS variables if any of the following are true: 1. The LHS variable has previously or through this iteration been marked AoS. 2. The LHS is a tuple projection * For functions see the documentation for query_initial_demotable_funs for the logic on demotion rules.
val query_demotable_stmt :
+ string Core.Set.Poly.t ->
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tLook through a statement to see whether the objects used in it need to be modified from SoA to AoS. Returns the set of object names that need demoted in a statement, if any. This function looks at Assignment statements, and returns back the set of top level object names given: 1. If the name of the lhs assignee is in the aos_exits, all the names of the expressions with a type containing a matrix are returned. 2. If the names of the rhs objects containing matrix types are in the subset of aos_exits.
val modify_kind :
+ ?force_demotion:bool ->
+ string Core.Set.Poly.t ->
+ Middle.Expr.Typed.t Middle.Fun_kind.t ->
+ Middle.Expr.Typed.t list ->
+ Middle.Expr.Typed.t Middle.Fun_kind.t * Middle.Expr.Typed.t listModify a function and it's subexpressions from SoA <-> AoS and vice versa. This performs demotion for sub expressions recursively. The top level expression and it's sub expressions are demoted to SoA if 1. The names of the variables in the subexpressions returning objects holding matrices are all in the modifiable set. 2. The function does not support SoA 3. The force argument is true
val modify_expr_pattern :
+ ?force_demotion:bool ->
+ string Core.Set.Poly.t ->
+ Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.t ->
+ Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.tModify an expression and it's subexpressions from SoA <-> AoS and vice versa. The only real paths in the below is on the functions and ternary expressions. * The logic for functions is defined in modify_kind. TernaryIf is forcefully demoted to AoS if the type of the expression contains a matrix.
val modify_expr :
+ ?force_demotion:bool ->
+ string Core.Set.Poly.t ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tGiven a Set of strings containing the names of objects that can be modified from AoS <-> SoA and vice versa, modify them within the expression.
val modify_stmt_pattern :
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.tModify statement patterns in the MIR from AoS <-> SoA and vice versa For Decl and Assignment's reading in parameters, we demote to AoS if the decl_id (or assign name) is in the modifiable set and otherwise promote the statement to SoA. For general Assignment statements, we check if the assignee is in the demotable set. If so, we force demotion of all of the rhs expressions. All other statements recurse over their statements and expressions. *
val modify_stmt :
+ Middle.Stmt.Located.t ->
+ string Core.Set.Poly.t ->
+ Middle.Stmt.Located.tModify statement patterns in the MIR from AoS <-> SoA and vice versa
val collect_mem_pattern_variables :
+ Middle.Stmt.Located.t Core.List.t ->
+ (string
+ * Middle.Expr.Typed.Meta.t Middle.Stmt.Fixed.First.t Middle.SizedType.t)
+ listval pp_mem_patterns : Stdlib.Format.formatter -> Middle.Program.Typed.t -> unitAnalysis_and_optimization.Mir_utilsval var_declarations : ('a, 'b) Middle.Stmt.Fixed.t -> string Core.Set.Poly.tval num_expr_value : Middle.Expr.Typed.t -> (float * string) optionval trans_bounds_values :
+ Middle.Expr.Typed.t Middle.Transformation.t ->
+ bound_valuesval top_var_declarations : Middle.Stmt.Located.t -> string Core.Set.Poly.tval data_set :
+ ?exclude_transformed:bool ->
+ ?exclude_ints:bool ->
+ Middle.Program.Typed.t ->
+ string Core.Set.Poly.tval parameter_set :
+ ?include_transformed:bool ->
+ Middle.Program.Typed.t ->
+ (string * Middle.Expr.Typed.t Middle.Transformation.t) Core.Set.Poly.tval parameter_names_set :
+ ?include_transformed:bool ->
+ Middle.Program.Typed.t ->
+ string Core.Set.Poly.tval fold_expr :
+ take_expr:('c -> Middle.Expr.Typed.t -> 'c) ->
+ init:'c ->
+ Middle.Expr.Typed.t ->
+ 'cval fold_stmts :
+ take_expr:('c -> Middle.Expr.Typed.t -> 'c) ->
+ take_stmt:('c -> Middle.Stmt.Located.t -> 'c) ->
+ init:'c ->
+ Middle.Stmt.Located.t Core.List.t ->
+ 'cval map_rec_expr :
+ (Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.t ->
+ Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.t) ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tval map_rec_expr_state :
+ ('s ->
+ Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.t ->
+ Middle.Expr.Typed.t Middle.Expr.Fixed.Pattern.t * 's) ->
+ 's ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.t * 'sval map_rec_stmt_loc :
+ ((Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t) ->
+ Middle.Stmt.Located.t ->
+ Middle.Stmt.Located.tval top_down_map_rec_stmt_loc :
+ ((Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t) ->
+ Middle.Stmt.Located.t ->
+ Middle.Stmt.Located.tval map_rec_state_stmt_loc :
+ ('s ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t
+ * 's) ->
+ 's ->
+ Middle.Stmt.Located.t ->
+ Middle.Stmt.Located.t * 'sval map_rec_stmt_loc_num :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t) ->
+ Middle.Stmt.Located.Non_recursive.t ->
+ Middle.Stmt.Located.tval stmt_loc_of_stmt_loc_num :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ Middle.Stmt.Located.Non_recursive.t ->
+ Middle.Stmt.Located.tval statement_stmt_loc_of_statement_stmt_loc_num :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.tval unnumbered_prog_of_numbered_prog :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ ('a -> 'b) ->
+ (Middle.Stmt.Located.Non_recursive.t, 'a, 'c) Middle.Program.t ->
+ (Middle.Stmt.Located.t, 'b, 'c) Middle.Program.tval fwd_traverse_statement :
+ ('e, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ init:'f ->
+ f:('f -> 'a -> 'f * 'c) ->
+ 'f * ('e, 'c) Middle.Stmt.Fixed.Pattern.tA traversal that simultaneously accumulates a state (type 'f) and replaces the substatement values from ('a to 'c). Traversal is done in-order but ignores branching, e.g., and if's then block is followed by the else block rather than branching.
val vexpr_of_expr_exn : Middle.Expr.Typed.t -> Dataflow_types.vexprTake a LHS expression from a general expression, throwing an exception if it can't be a LHS expression.
val expr_var_set :
+ Middle.Expr.Typed.t ->
+ (Dataflow_types.vexpr * Middle.Expr.Typed.Meta.t) Core.Set.Poly.tThe set of variables in an expression, including inside an index. For use in RHS sets, not LHS assignment sets, except in a target term.
val index_var_set :
+ Middle.Expr.Typed.t Middle.Index.t ->
+ (Dataflow_types.vexpr * Middle.Expr.Typed.Meta.t) Core.Set.Poly.tThe set of variables in an index. For use in RHS sets, not LHS assignment sets, except in a target term
val expr_var_names_set : Middle.Expr.Typed.t -> string Core.Set.Poly.tReturn the names of the variables in an expression.
val stmt_rhs :
+ (Middle.Expr.Typed.t, 's) Middle.Stmt.Fixed.Pattern.t ->
+ Middle.Expr.Typed.t Core.Set.Poly.tThe set of variables that can affect the value or behavior of the expression, i.e. rhs. Using Set.Poly instead of ExprSet so that 'e can be polymorphic, it usually doesn't matter if there's duplication.
This is a helper function equivalent to List.concat_map but for Sets
val stmt_rhs_var_set :
+ (Middle.Expr.Typed.t, 's) Middle.Stmt.Fixed.Pattern.t ->
+ (Dataflow_types.vexpr * Middle.Expr.Typed.Meta.t) Core.Set.Poly.tThe set of variables in an expression, including inside an index. For use in RHS sets, not LHS assignment sets, except in a target term.
val expr_assigned_var : Middle.Expr.Typed.t -> Dataflow_types.vexprThe variable being assigned to when the expression is the LHS
val summation_terms : Middle.Expr.Typed.t -> Middle.Expr.Typed.t listThe list of terms in expression separated by a +
val subst_expr :
+ (string, Middle.Expr.Typed.t) Core.Map.Poly.t ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tSubstitute variables in an expression according to the provided Map.
val subst_stmt_base :
+ (string, Middle.Expr.Typed.t) Core.Map.Poly.t ->
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.tSubstitute variables occurring at the top level in statements according to the provided Map.
val subst_stmt :
+ (string, Middle.Expr.Typed.t) Core.Map.Poly.t ->
+ Middle.Stmt.Located.t ->
+ Middle.Stmt.Located.tSubstitute variables occurring anywhere in a statement according to the provided Map.
val name_subst_stmt :
+ (string, string) Core.Map.Poly.t ->
+ Middle.Stmt.Located.t ->
+ Middle.Stmt.Located.tSubstitute subexpressions occurring anywhere in a statement according to the provided Map.
val expr_subst_expr :
+ Middle.Expr.Typed.t Middle.Expr.Typed.Map.t ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tSubstitute subexpressions in an expression according to the provided Map, trying to match on larger subexpressions before smaller ones.
val expr_subst_stmt_base :
+ Middle.Expr.Typed.t Middle.Expr.Typed.Map.t ->
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.tSubstitute subexpressions occurring at the top level in statements according to the provided Map.
val expr_depth : Middle.Expr.Typed.t -> intCalculate how deeply nested an expression is.
val update_expr_ad_levels :
+ string Core.Set.Poly.t ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tRecompute all AD-levels in the metadata of an expression from the bottom up, making the variables in the first argument autodiffable
val cleanup_empty_stmts :
+ ('e, 's) Middle.Stmt.Fixed.t list ->
+ ('e, 's) Middle.Stmt.Fixed.t listval unsafe_unsized_to_sized_type :
+ Middle.Expr.Typed.t Middle.Type.t ->
+ Middle.Expr.Typed.t Middle.Type.tAnalysis_and_optimization.Monotone_frameworkThe common elements of a monotone framework
val print_mfp :
+ ('a -> Core__.Import.string) ->
+ (int, ('a, 'b) Core__Set.t Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.t ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ unitDebugging tool to print out MFP sets *
val free_vars_expr : Middle.Expr.Typed.t -> string Core.Set.Poly.tCalculate the free (non-bound) variables in an expression
val free_vars_idx :
+ Middle.Expr.Typed.t Middle.Index.t ->
+ string Core.Set.Poly.tCalculate the free (non-bound) variables in an index
val free_vars_fnapp :
+ Middle.Expr.Typed.t Middle.Fun_kind.t ->
+ Middle.Expr.Typed.t Base__List.t ->
+ string Core.Set.Poly.tval free_vars_lval :
+ Middle.Expr.Typed.t Middle.Stmt.Fixed.Pattern.lvalue ->
+ string Core.Set.Poly.tval free_vars_stmt :
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tCalculate the free (non-bound) variables in a statement
val top_free_vars_stmt :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tA variation on free_vars_stmt, where we do not recursively count free variables in sub statements
val inverse_flowgraph_of_stmt :
+ ?flatten_loops:bool ->
+ ?blocks_after_body:bool ->
+ Middle.Stmt.Located.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH
+ with type labels = int)
+ * (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.tCompute the inverse flowgraph of a Stan statement (for reverse analyses)
val reverse :
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = 'l) ->
+ (module Monotone_framework_sigs.FLOWGRAPH
+ with type labels = 'l0)Reverse flowgraphs to be used for reverse analyses. Observe that this respects the invariants listed for a FLOWGRAPH
val make_circular_flowgraph :
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = 'l) ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = 'l0) ->
+ (module Monotone_framework_sigs.FLOWGRAPH
+ with type labels = 'l1)Modify the end nodes of a flowgraph to depend on its inits To force the monotone framework to run until the program never changes this function modifies the input Flowgraph so that it's end nodes depend on it's initial nodes. The inits of the reverse flowgraph are used for this since we normally have both the forward and reverse flowgraphs available.
val forward_flowgraph_of_stmt :
+ ?flatten_loops:bool ->
+ ?blocks_after_body:bool ->
+ Middle.Stmt.Located.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH
+ with type labels = int)
+ * (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.tCompute the forward flowgraph of a Stan statement (for forward analyses)
val powerset_lattice :
+ (module Monotone_framework_sigs.INITIALTYPE with type vals = 'v) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = 'v0 Core.Set.Poly.t)The lattice of sets of some values, with the inclusion order, set union and the empty set
val dual_powerset_lattice :
+ (module Monotone_framework_sigs.INITIALTOTALTYPE with type vals = 'v) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = 'v0 Core.Set.Poly.t)The lattice of subsets of some set, with the inverse inclusion order, set intersection and the total set
val powerset_lattice_expressions :
+ Middle.Expr.Typed.Set.t ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = Middle.Expr.Typed.Set.t)val dual_powerset_lattice_expressions :
+ Middle.Expr.Typed.Set.t ->
+ Middle.Expr.Typed.Set.t ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = Middle.Expr.Typed.Set.t)val new_bot :
+ (module Monotone_framework_sigs.LATTICE_NO_BOT with type properties = 'p) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = 'p0 option)Add a fresh bottom element to a lattice (possibly without bottom)
val dual_partial_function_lattice :
+ (module Monotone_framework_sigs.TOTALTYPE with type vals = 'dv) ->
+ (module Monotone_framework_sigs.TYPE with type vals = 'cv) ->
+ (module Monotone_framework_sigs.LATTICE_NO_BOT
+ with type properties = ('dv0, 'cv0) Core.Map.Poly.t)The lattice (without bottom) of partial functions, ordered under inverse graph inclusion, with intersection
val dual_partial_function_lattice_with_bot :
+ (module Monotone_framework_sigs.TOTALTYPE with type vals = 'dv) ->
+ (module Monotone_framework_sigs.TYPE with type vals = 'cv) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = ('dv0, 'cv0) Core.Map.Poly.t option)The lattice of partial functions, where we add a fresh bottom element, to represent an inconsistent combination of functions
val dual_powerset_lattice_empty_initial :
+ (module Monotone_framework_sigs.TOTALTYPE with type vals = 'v) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = 'v0 Core.Set.Poly.t)A dual powerset lattice, where we set the initial set to be empty
val powerset_lattice_empty_initial :
+ (module Monotone_framework_sigs.TYPE with type vals = 'v) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = 'v0 Core.Set.Poly.t)A powerset lattice, where we set the initial set to be empty
val reaching_definitions_lattice :
+ (module Monotone_framework_sigs.INITIALTYPE with type vals = 'v) ->
+ (module Monotone_framework_sigs.TYPE with type vals = 'l) ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = ('v0 * 'l0 option) Core.Set.Poly.t)The specific powerset lattice we use for reaching definitions analysis
val minimal_variables_lattice :
+ string Core.Set.Poly.t ->
+ (module Monotone_framework_sigs.LATTICE
+ with type properties = string Core.Set.Poly.t)Lattice for finding the smallest set that satisfies some criterion
val constant_propagation_transfer :
+ ?preserve_stability:bool ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = (string, Middle.Expr.Typed.t) Core.Map.Poly.t option)val label_top_decls :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ int ->
+ string Core.Set.Poly.tval expression_propagation_transfer :
+ ?preserve_stability:bool ->
+ (Middle.Expr.Typed.t -> bool) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = (string, Middle.Expr.Typed.t) Core.Map.Poly.t option)The transfer function for an expression propagation analysis, AKA forward substitution (see page 396 of Muchnick)
val copy_propagation_transfer :
+ string Core.Set.Poly.t ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = (string, Middle.Expr.Typed.t) Core.Map.Poly.t option)The transfer function for a copy propagation analysis
val transfer_gen_kill :
+ ('a, 'b) Core.Set.t ->
+ ('c, 'd) Core.Set.t ->
+ ('a, 'b) Core.Set.t ->
+ ('c, 'd) Core.Set.tA helper function for building transfer functions from gen and kill sets
val assigned_vars_stmt :
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tCalculate the set of variables that a statement can assign to
val declared_vars_stmt :
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tCalculate the set of variables that a statement can declare
val assigned_or_declared_vars_stmt :
+ (Middle.Expr.Typed.t, 'a) Middle.Stmt.Fixed.Pattern.t ->
+ (string, Core__.Comparator.Poly.comparator_witness) Core.Set.tCalculate the set of variables that a statement can assign to or declare
val reaching_definitions_transfer :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = (string * int option) Core.Set.Poly.t)The transfer function for a reaching definitions analysis
val initialized_vars_transfer :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = string Core.Set.Poly.t)The transfer function for an initialized variables analysis
val live_variables_transfer :
+ string Core.Set.Poly.t ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = string Core.Set.Poly.t)The transfer function for a live variables analysis
val used_subexpressions_expr :
+ Middle.Expr.Typed.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the set of sub-expressions of an expression
val used_expressions_idx_help :
+ (Middle.Expr.Typed.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t) ->
+ Middle.Expr.Typed.t Middle.Index.t ->
+ Middle.Expr.Typed.Set.tval used_expressions_lval :
+ (Middle.Expr.Typed.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t) ->
+ Middle.Expr.Typed.t Middle.Stmt.Fixed.Pattern.lvalue ->
+ Middle.Expr.Typed.Set.tval used_expressions_expr :
+ Middle.Expr.Typed.Set.Elt.t ->
+ Middle.Expr.Typed.Set.tCalculate the set of expressions of an expression
val used_expressions_stmt_help :
+ (Middle.Expr.Typed.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t) ->
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tval used_subexpressions_stmt :
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the set of sub-expressions in a statement
val used_expressions_stmt :
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the set of expressions in a statement
val top_used_expressions_stmt_help :
+ (Middle.Expr.Typed.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t) ->
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tval top_used_subexpressions_stmt :
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the set of sub-expressions at the top level in a statement
val top_used_expressions_stmt :
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the set of expressions at the top level in a statement
val killed_expressions_stmt :
+ Middle.Expr.Typed.Set.t ->
+ (Middle.Expr.Typed.t, int) Middle.Stmt.Fixed.Pattern.t ->
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.tCalculate the subset (of p) of expressions that will need to be recomputed as a consequence of evaluating the statement s (because of writes to variables performed by s)
val used :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int,
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t)
+ Core.Map.Poly.tCalculate the set of subexpressions that needs to be computed at each node in the flowgraph
val anticipated_expressions_transfer :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = Middle.Expr.Typed.Set.t)The transfer function for an anticipated expressions analysis (as a part of lazy code motion)
val transfer_gen_kill_alt :
+ ('a, 'b) Core.Set.t ->
+ ('a, 'b) Core.Set.t ->
+ ('c, 'd) Core.Set.t ->
+ ('c, 'd) Core.Set.tA helper function for defining transfer functions in terms of gen and kill sets in an alternative way, that is used in some of the subanalyses of lazy code motion
val available_expressions_transfer :
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = Middle.Expr.Typed.Set.t)An available expressions analysis, to be used in lazy code motion
val earliest :
+ (int, Middle.Expr.Typed.Set.t Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.t ->
+ (int,
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t)
+ Core.Map.Poly.tCalculates the set of expressions that can be calculated for the first time at each node in the flow graph
val postponable_expressions_transfer :
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = Middle.Expr.Typed.Set.t)The transfer function for a postponable expressions analysis (as a part of lazy code motion)
val latest :
+ (int, int Core.Set.Poly.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (int,
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t)
+ Core.Map.Poly.tCalculates the set of expressions that can be computed at the latest at each node
val used_not_latest_expressions_transfer :
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (int, Middle.Expr.Typed.Set.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = Middle.Expr.Typed.Set.t)The transfer function for a used-not-latest expressions analysis, as a part of lazy code motion
val minimal_variables_fwd_transfer :
+ ((int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ int ->
+ string Core.Set.Poly.t ->
+ string Core.Set.Poly.t) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = string Core.Set.Poly.t)The transfer function for the first forward analysis part of determining optimal ad-levels for variables
val monotone_framework :
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = 'l) ->
+ (module Monotone_framework_sigs.LATTICE with type properties = 'p) ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = 'l0
+ and type properties = 'p0) ->
+ (module Monotone_framework_sigs.MONOTONE_FRAMEWORK
+ with type labels = 'l1
+ and type properties = 'p1)The central definition of a monotone dataflow analysis framework. Given a compatible flowgraph, lattice and transfer function, we can run the mfp (maximal fixed point) algorithm, which computes a maximal fixed point (MFP) for the set of equations/inequalities of properties at the entry and exit of each node in the flow graph, as defined by the triple. Note that this gives a safe approximation to the MOP (meet over all paths) solution that we would really be interested in, but which is often incomputable. In case of a distributive lattice of properties, the MFP and MOP solutions coincide.
val declared_variables_stmt :
+ (Middle.Expr.Typed.t, Middle.Stmt.Located.t) Middle.Stmt.Fixed.Pattern.t ->
+ string Core.Set.Poly.tval propagation_mfp :
+ Middle.Program.Typed.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ ((int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (module Monotone_framework_sigs.TRANSFER_FUNCTION
+ with type labels = int
+ and type properties = (string, Middle.Expr.Typed.t) Core.Map.Poly.t option)) ->
+ (int,
+ (string, Middle.Expr.Typed.t) Core.Map.Poly.t option
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tval reaching_definitions_mfp :
+ Middle.Program.Typed.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int,
+ (string * int option) Core.Set.Poly.t
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tval initialized_vars_mfp :
+ string Core.Set.Poly.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int,
+ string Core.Set.Poly.t
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tval globals : Middle.Program.Typed.t -> string Core.Set.Poly.tval live_variables_mfp :
+ Middle.Program.Typed.t ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int,
+ string Core.Set.Poly.t
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tMonotone framework instance for live_variables analysis. Expects reverse flowgraph.
val lazy_expressions_mfp :
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ (int,
+ (Middle.Expr.Typed.Set.Elt.t, Middle.Expr.Typed.Set.Elt.comparator_witness)
+ Core.Set.t)
+ Core.Map.Poly.t
+ * (int,
+ Middle.Expr.Typed.Set.t
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tInstantiate all four instances of the monotone framework for lazy code motion, reusing code between them
val minimal_variables_mfp :
+ (module Monotone_framework_sigs.FLOWGRAPH with type labels = int) ->
+ (int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ string Core.Set.Poly.t ->
+ ((int, Middle.Stmt.Located.Non_recursive.t) Core.Map.Poly.t ->
+ int ->
+ string Core.Set.Poly.t ->
+ string Core.Set.Poly.t) ->
+ (int,
+ string Core.Set.Poly.t
+ Analysis_and_optimization__Monotone_framework_sigs.entry_exit)
+ Core.Map.Poly.tRun the minimal fixed point algorithm to deduce the smallest set of variables that satisfy a set of conditions.
Analysis_and_optimization.Monotone_framework_sigsThe API for a monotone framework, as described in 2.3-2.4 of Nielson, Nielson, and Hankin or 9.3 of Aho et al.. This gives a modular way of implementing many static analyses.
module type FLOWGRAPH = sig ... endThe API for a flowgraph, needed for the mfp algorithm in the monotone framework. Assumed invariants: successors contains all graph nodes as keys initials is a subset of the graph nodes
module type TYPE = sig ... endThe minimal data we need to use a type in forming a lattice of various kinds
module type INITIALTYPE = sig ... endThe data we need to form a powerset lattice
module type TOTALTYPE = sig ... endThe data we need to form e.g. an available xpressions lattice
module type INITIALTOTALTYPE = sig ... endThe data we need to form a dual powerset lattice
module type LATTICE_NO_BOT = sig ... endmodule type LATTICE = sig ... endThe API for a complete (possibly non-distributive) lattice, needed for the mfp algorithm in the monotone framework
module type TRANSFER_FUNCTION = sig ... endThe API for a transfer function, needed for the mfp algorithm in the monotone framework. This describes how output properties are computed from input properties at a given node in the flow graph.
module type MONOTONE_FRAMEWORK = sig ... endThe API for a monotone framework. mfp computes the minimal fixed point of the equations/inequalities defined between property lattice elements at the entry and exit of different flowgraph nodes, where these equations/inequalities are generated from the transfer function. Returns a map of the (input_properties, output_properties) for each node l in the flow graph. The analysis performed is always a forward analysis. For a reverse analysis, supply the reverse flow graph.
Monotone_framework_sigs.FLOWGRAPHThe API for a flowgraph, needed for the mfp algorithm in the monotone framework. Assumed invariants: successors contains all graph nodes as keys initials is a subset of the graph nodes
type t = labelsval compare : t Base__Ppx_compare_lib.compareval sexp_of_t : t -> Sexplib0.Sexp.tval hash : t -> intval initials : labels Core.Set.Poly.tMonotone_framework_sigs.INITIALTOTALTYPEThe data we need to form a dual powerset lattice
Monotone_framework_sigs.INITIALTYPEThe data we need to form a powerset lattice
Monotone_framework_sigs.LATTICEThe API for a complete (possibly non-distributive) lattice, needed for the mfp algorithm in the monotone framework
include LATTICE_NO_BOTval leq : properties -> properties -> boolval initial : propertiesAn initial value, which might not be the top element. The idea is that this is the property that you start with (you assume to be true at the start of your analysis).
val lub : properties -> properties -> propertiesval bottom : propertiesMonotone_framework_sigs.LATTICE_NO_BOTval leq : properties -> properties -> boolval initial : propertiesAn initial value, which might not be the top element. The idea is that this is the property that you start with (you assume to be true at the start of your analysis).
val lub : properties -> properties -> propertiesMonotone_framework_sigs.MONOTONE_FRAMEWORKThe API for a monotone framework. mfp computes the minimal fixed point of the equations/inequalities defined between property lattice elements at the entry and exit of different flowgraph nodes, where these equations/inequalities are generated from the transfer function. Returns a map of the (input_properties, output_properties) for each node l in the flow graph. The analysis performed is always a forward analysis. For a reverse analysis, supply the reverse flow graph.
Monotone_framework_sigs.TOTALTYPEThe data we need to form e.g. an available xpressions lattice
Monotone_framework_sigs.TRANSFER_FUNCTIONThe API for a transfer function, needed for the mfp algorithm in the monotone framework. This describes how output properties are computed from input properties at a given node in the flow graph.
Monotone_framework_sigs.TYPEThe minimal data we need to use a type in forming a lattice of various kinds
Analysis_and_optimization.Optimizeval function_inlining : Middle.Program.Typed.t -> Middle.Program.Typed.tInline all functions except for ones with forward declarations (e.g. recursive functions, mutually recursive functions, and functions without a definition
val static_loop_unrolling : Middle.Program.Typed.t -> Middle.Program.Typed.tUnroll all for-loops with constant bounds, as long as they do not contain break or continue statements in their body at the top level
val one_step_loop_unrolling : Middle.Program.Typed.t -> Middle.Program.Typed.tUnroll all loops for one iteration, as long as they do not contain break or continue statements in their body at the top level
val list_collapsing : Middle.Program.Typed.t -> Middle.Program.Typed.tRemove redundant SList constructors from the Mir that might have been introduced by other optimizations
val block_fixing : Middle.Program.Typed.t -> Middle.Program.Typed.tMake sure that SList constructors directly under if, for, while or fundef constructors are replaced with Block constructors. This should probably be run before we generate code.
val constant_propagation :
+ ?preserve_stability:bool ->
+ Middle.Program.Typed.t ->
+ Middle.Program.Typed.tPropagate constant values through variable assignments
val expression_propagation :
+ ?preserve_stability:bool ->
+ Middle.Program.Typed.t ->
+ Middle.Program.Typed.tPropagate arbitrary expressions through variable assignments. This can be useful for opening up new possibilities for partial evaluation. It should be followed by some CSE or lazy code motion pass, however.
val copy_propagation : Middle.Program.Typed.t -> Middle.Program.Typed.tPropagate copies of variables through assignments.
val dead_code_elimination : Middle.Program.Typed.t -> Middle.Program.Typed.tEliminate semantically redundant code branches. This includes removing redundant assignments (because they will be overwritten) and removing redundant code in program branches that will never be reached.
val partial_evaluation : Middle.Program.Typed.t -> Middle.Program.Typed.tPartially evaluate expressions in the program. This includes simplification using algebraic identities of logical and arithmetic operators as well as Stan math functions.
val lazy_code_motion :
+ ?preserve_stability:bool ->
+ Middle.Program.Typed.t ->
+ Middle.Program.Typed.tPerform partial redundancy elmination using the lazy code motion algorithm. This subsumes common subexpression elimination and loop-invariant code motion.
val optimize_ad_levels : Middle.Program.Typed.t -> Middle.Program.Typed.tAssign the optimal ad-levels to local variables. That means, make sure that variables only ever get treated as autodiff variables if they have some dependency on a parameter
val allow_uninitialized_decls :
+ Middle.Program.Typed.t ->
+ Middle.Program.Typed.tMarks Decl types such that, if the first assignment after the decl assigns to the full object, allow the object to be constructed but not uninitialized.
type optimization_settings = {function_inlining : bool;static_loop_unrolling : bool;one_step_loop_unrolling : bool;list_collapsing : bool;block_fixing : bool;allow_uninitialized_decls : bool;constant_propagation : bool;expression_propagation : bool;copy_propagation : bool;dead_code_elimination : bool;partial_evaluation : bool;lazy_code_motion : bool;optimize_ad_levels : bool;preserve_stability : bool;optimize_soa : bool;}Interface for turning individual optimizations on/off. Useful for testing and for top-level interface flags.
val all_optimizations : optimization_settingsval no_optimizations : optimization_settingsval level_optimizations : optimization_level -> optimization_settingsval optimization_suite :
+ ?settings:optimization_settings ->
+ Middle.Program.Typed.t ->
+ Middle.Program.Typed.tPerform all optimizations in this module on the MIR in an appropriate order.
Analysis_and_optimization.Partial_evaluatorexception Rejected of Middle.Location_span.t * stringval is_int : int -> 'a Middle.Expr.Fixed.t -> boolval apply_prefix_operator_int :
+ string ->
+ Core.Int.t ->
+ 'a Middle.Expr.Fixed.Pattern.tval apply_prefix_operator_real :
+ string ->
+ Core.Float.t ->
+ 'a Middle.Expr.Fixed.Pattern.tval apply_operator_int :
+ string ->
+ Core__.Int.t ->
+ Core__.Int.t ->
+ 'a Middle.Expr.Fixed.Pattern.tval apply_arithmetic_operator_real :
+ string ->
+ float ->
+ float ->
+ 'a Middle.Expr.Fixed.Pattern.tval apply_logical_operator_real :
+ string ->
+ 'a ->
+ 'b ->
+ 'c Middle.Expr.Fixed.Pattern.tval is_multi_index : 'a Middle.Index.t -> boolval eval_expr :
+ ?preserve_stability:bool ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.tval simplify_index_expr :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Expr.Fixed.Pattern.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Expr.Fixed.Pattern.tval remove_trailing_alls_expr :
+ 'a Middle.Expr.Fixed.Pattern.t ->
+ 'b Middle.Expr.Fixed.Pattern.tval simplify_indices_expr :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.tval try_eval_expr : Middle.Expr.Typed.t -> Middle.Expr.Typed.tval eval_stmt :
+ (Middle.Expr.Typed.Meta.t, Middle.Location_span.t) Middle.Stmt.Fixed.t ->
+ (Middle.Expr.Typed.Meta.t, Middle.Location_span.t) Middle.Stmt.Fixed.tval eval_prog :
+ (Middle.Expr.Typed.t,
+ (Middle.Expr.Typed.Meta.t, Middle.Location_span.t) Middle.Stmt.Fixed.t,
+ Middle.Location_span.t)
+ Middle.Program.t ->
+ Middle.Program.Typed.tAnalysis_and_optimization.Pedantic_analysistype warning_span = Middle.Location_span.t * stringval warn_pedantic : Middle.Program.Typed.t -> warning_span listCollect all pedantic mode warnings and print to a string.
val warn_uninitialized : Middle.Program.Typed.t -> warning_span listCollect warnings about each variable which is used before being initialized and print to a string.
Analysis_and_optimization.Pedantic_dist_warningstype compiletime_val = | Opaque| Number of float * string| Param of string * Middle.Expr.Typed.t Middle.Transformation.t| Data of stringUseful information about an expression. Opaque means we don't know anything.
type dist_info = {name : string;loc : Middle.Location_span.t;args : (compiletime_val * Middle.Expr.Typed.Meta.t) Core.List.t;}Info about a distribution occurrences that's useful for checking that distribution properties are met
Value constraint as a range. The bools are true if the bound is inclusive
type var_constraint = | Range of range| Ordered| PositiveOrdered| Simplex| UnitVector| CholeskyCorr| CholeskyCov| Correlation| CovarianceValue constraint for an argument
Constraint paired with a name for user messages
val unit_range : var_constraint_namedval exclusive_unit_range : var_constraint_namedval positive_range : var_constraint_namedval nonnegative_range : var_constraint_namedval simplex : var_constraint_namedval ordered : var_constraint_namedval correlation : var_constraint_namedval cholesky_correlation : var_constraint_namedval covariance : var_constraint_namedval cholesky_covariance : var_constraint_namedval bounds_out_of_range : range -> Mir_utils.bound_values -> boolCheck for inconsistency between a distribution argument's value range and the declared bounds of a variable
val transform_mismatch_constraint :
+ var_constraint ->
+ Middle.Expr.Typed.t Middle.Transformation.t ->
+ boolCheck for inconsistency between a distribution argument's constraint and the constraint transformation of a variable
val value_out_of_range : range -> float -> boolCheck for inconsistency between a distribution argument's range and a literal value
val value_mismatch_constraint : var_constraint -> float -> boolCheck for inconsistency between a distribution argument's constraint and a literal value
val arg_number : arg_info -> intval constr_mismatch_message : string -> string -> arg_info -> string -> stringval constr_literal_mismatch_message :
+ string ->
+ string ->
+ arg_info ->
+ string ->
+ stringval constr_mismatch_warning :
+ var_constraint_named ->
+ arg_info ->
+ dist_info ->
+ (Middle.Location_span.t * string) optionReturn a warning if the argn-th argument doesn't match its constraints
val uniform_dist_warning :
+ dist_info ->
+ (Middle.Location_span.t * string) optionWarning for all uniform distributions with a parameter
val lkj_corr_dist_warning :
+ dist_info ->
+ (Middle.Location_span.t * string) optionWarn about all non-Cholesky lkj_corr distributions
val gamma_arg_dist_warning :
+ dist_info ->
+ (Middle.Location_span.t * string) optionWarning particular to gamma and inv_gamma, when A=B<1
val distribution_warning :
+ dist_info ->
+ (Middle.Location_span.t * string) Core.List.tGenerate all of the warnings that are relevant to a given distribution
val distribution_warnings :
+ dist_info Core.Set.Poly.t ->
+ (Middle.Location_span.t * string) Core.Set.Poly.tGenerate the distribution warnings for a program
Analysis_and_optimizationmodule Dataflow_types : sig ... endmodule Dataflow_utils : sig ... endmodule Debug_data_generation : sig ... endmodule Dependence_analysis : sig ... end~~~~~ TODO ~~~~~ * The interfaces are currently messed up. I think part of the solution is to change the signature of reaching_definitions_mfp in Monotone_framework, which currently requires the full program but shouldn't need the full program. As it stands, stmt_map_dependency_graph does not include data dependencies at all, since it can't use reaching deps, and prog_dependency graph only builds the graph for log_prob, but the user isn't guaranteed to be using the same labeling scheme. * Currently, dependencies on global or uninitialized data are written as depending on node '0'. This should probably be option or some type that indicates global dependence. * Indexed variables are currently handled as monoliths * No probabilistic dependency, I'll do that elsewhere *
module Factor_graph : sig ... endmodule Memory_patterns : sig ... endmodule Mir_utils : sig ... endmodule Monotone_framework : sig ... endThe common elements of a monotone framework
module Monotone_framework_sigs : sig ... endmodule Optimize : sig ... endmodule Partial_evaluator : sig ... endmodule Pedantic_analysis : sig ... endmodule Pedantic_dist_warnings : sig ... endMake.Patternval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Fixed.MakeFunctor which creates the fixed-point of the type defined in the Pattern module argument
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
fold_pattern traverses the data structure from the bottom up replacing the original meta data of type 'a with some result type 'r and combines the result values on the way back up. For example, given a pattern with the following type:
type 'a pattern = Leaf of string | Branch of 'a * 'a
we can use fold_pattern to calculate the maximum depth of data structure obtained by fixing the pattern type:
let max_depth t =
+ let f = function
+ | meta , Leaf _ -> 1
+ | meta , Branch(left_depth,right_depth) ->
+ 1 + (max left_depth right_depth)
+ in
+ fold_pattern ~f tNote that the function 'f' supplied to fold_pattern accepts a tuple rather than our type 'a t since the type of the pattern has been transformed to 'r t Pattern.t and is no longer 'compatible' with the original type of meta data 'a. That is, a tuple ('a * 'b t Pattern.t) has two type variables where as 'a t has one.
rewrite_bottom_up specializes fold_pattern so that the result type 'r is equal to the type of our fixed-point data structure i.e. 'r = 'a t. This also means that the function f can be written with our fixed-point type 'a t as its argument.
unfold builds a fixed-point data structure from the top down. Starting with a user-supplied seed of type 'r, unfold recursively applies the function f yielding a tuple of meta-data and pattern with elements of type 'r to which f is further applied.
The unfold terminates when a pattern element which does not carry an 'r is reached.
As with fold_pattern the function f returns a tuple of meta-data and pattern rather than our record type since, in general, 'r =/= 'a t.
First.Patternval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Make2.Firstval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
fold_pattern traverses the data structure from the bottom up replacing the original meta data of type 'a with some result type 'r and combines the result values on the way back up. For example, given a pattern with the following type:
type 'a pattern = Leaf of string | Branch of 'a * 'a
we can use fold_pattern to calculate the maximum depth of data structure obtained by fixing the pattern type:
let max_depth t =
+ let f = function
+ | meta , Leaf _ -> 1
+ | meta , Branch(left_depth,right_depth) ->
+ 1 + (max left_depth right_depth)
+ in
+ fold_pattern ~f tNote that the function 'f' supplied to fold_pattern accepts a tuple rather than our type 'a t since the type of the pattern has been transformed to 'r t Pattern.t and is no longer 'compatible' with the original type of meta data 'a. That is, a tuple ('a * 'b t Pattern.t) has two type variables where as 'a t has one.
rewrite_bottom_up specializes fold_pattern so that the result type 'r is equal to the type of our fixed-point data structure i.e. 'r = 'a t. This also means that the function f can be written with our fixed-point type 'a t as its argument.
unfold builds a fixed-point data structure from the top down. Starting with a user-supplied seed of type 'r, unfold recursively applies the function f yielding a tuple of meta-data and pattern with elements of type 'r to which f is further applied.
The unfold terminates when a pattern element which does not carry an 'r is reached.
As with fold_pattern the function f returns a tuple of meta-data and pattern rather than our record type since, in general, 'r =/= 'a t.
Make2.Patternval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolFixed.Make2module Pattern : Pattern.S2val fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval fold_pattern :
+ f:(('a * 'r1 First.Pattern.t) -> 'r1) ->
+ g:(('b * ('r1, 'r2) Pattern.t) -> 'r2) ->
+ ('a, 'b) t ->
+ 'r2fold_pattern traverses the data structure from the bottom up replacing the original meta data of First with type 'a with some result type 'r1 and the meta data at this level withtype 'b to another result type 'r2 and combines the result values on the way back up.
val rewrite_bottom_up :
+ f:('a First.t -> 'a First.t) ->
+ g:(('a, 'b) t -> ('a, 'b) t) ->
+ ('a, 'b) t ->
+ ('a, 'b) trewrite_bottom_up specializes fold_pattern so that the result type 'r1 is equal to the type of the nested fixed-point type i.e. 'r1 = 'a First.t and the result type 'r2 is equal to the top-level fixed-point type i.e. 'r2 = ('a,'b) t.
This also means that the function f can be written with our nested fixed-point type 'a First.t as its argument and g can be written with ('a,'b) t as its argument.
val unfold_pattern :
+ f:('r1 -> 'a * 'r1 First.Pattern.t) ->
+ g:('r2 -> 'b * ('r1, 'r2) Pattern.t) ->
+ 'r2 ->
+ ('a, 'b) tunfold_pattern takes a seed value of type 'r2 and uses the function g to generate a tuple of meta-data and a pattern with types 'r1 and 'r2. The functions proceeds by recursively applying g to the contained values of type 'r2 and f to values of type 'r1 finishing when the pattern contains no values of type 'r1 or 'r2.
Common.FixedThis module defines the signatures and Make functors for the 'fixed point' (or two-level) type we use for our intermediate representations
module type S = sig ... endThe fixed-point of Pattern.t annotated with some meta-data
Functor which creates the fixed-point of the type defined in the Pattern module argument
module type S2 = sig ... endNested fixed-point type where an element of the Pattern is itself a fixed-point type. We use this to represent statements which contain expressions.
S.Patternval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Fixed.SThe fixed-point of Pattern.t annotated with some meta-data
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
fold_pattern traverses the data structure from the bottom up replacing the original meta data of type 'a with some result type 'r and combines the result values on the way back up. For example, given a pattern with the following type:
type 'a pattern = Leaf of string | Branch of 'a * 'a
we can use fold_pattern to calculate the maximum depth of data structure obtained by fixing the pattern type:
let max_depth t =
+ let f = function
+ | meta , Leaf _ -> 1
+ | meta , Branch(left_depth,right_depth) ->
+ 1 + (max left_depth right_depth)
+ in
+ fold_pattern ~f tNote that the function 'f' supplied to fold_pattern accepts a tuple rather than our type 'a t since the type of the pattern has been transformed to 'r t Pattern.t and is no longer 'compatible' with the original type of meta data 'a. That is, a tuple ('a * 'b t Pattern.t) has two type variables where as 'a t has one.
rewrite_bottom_up specializes fold_pattern so that the result type 'r is equal to the type of our fixed-point data structure i.e. 'r = 'a t. This also means that the function f can be written with our fixed-point type 'a t as its argument.
unfold builds a fixed-point data structure from the top down. Starting with a user-supplied seed of type 'r, unfold recursively applies the function f yielding a tuple of meta-data and pattern with elements of type 'r to which f is further applied.
The unfold terminates when a pattern element which does not carry an 'r is reached.
As with fold_pattern the function f returns a tuple of meta-data and pattern rather than our record type since, in general, 'r =/= 'a t.
First.Patternval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
S2.Firstval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
fold_pattern traverses the data structure from the bottom up replacing the original meta data of type 'a with some result type 'r and combines the result values on the way back up. For example, given a pattern with the following type:
type 'a pattern = Leaf of string | Branch of 'a * 'a
we can use fold_pattern to calculate the maximum depth of data structure obtained by fixing the pattern type:
let max_depth t =
+ let f = function
+ | meta , Leaf _ -> 1
+ | meta , Branch(left_depth,right_depth) ->
+ 1 + (max left_depth right_depth)
+ in
+ fold_pattern ~f tNote that the function 'f' supplied to fold_pattern accepts a tuple rather than our type 'a t since the type of the pattern has been transformed to 'r t Pattern.t and is no longer 'compatible' with the original type of meta data 'a. That is, a tuple ('a * 'b t Pattern.t) has two type variables where as 'a t has one.
rewrite_bottom_up specializes fold_pattern so that the result type 'r is equal to the type of our fixed-point data structure i.e. 'r = 'a t. This also means that the function f can be written with our fixed-point type 'a t as its argument.
unfold builds a fixed-point data structure from the top down. Starting with a user-supplied seed of type 'r, unfold recursively applies the function f yielding a tuple of meta-data and pattern with elements of type 'r to which f is further applied.
The unfold terminates when a pattern element which does not carry an 'r is reached.
As with fold_pattern the function f returns a tuple of meta-data and pattern rather than our record type since, in general, 'r =/= 'a t.
S2.Patternval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolFixed.S2Nested fixed-point type where an element of the Pattern is itself a fixed-point type. We use this to represent statements which contain expressions.
module Pattern : Pattern.S2val fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval fold_pattern :
+ f:(('a * 'r1 First.Pattern.t) -> 'r1) ->
+ g:(('b * ('r1, 'r2) Pattern.t) -> 'r2) ->
+ ('a, 'b) t ->
+ 'r2fold_pattern traverses the data structure from the bottom up replacing the original meta data of First with type 'a with some result type 'r1 and the meta data at this level withtype 'b to another result type 'r2 and combines the result values on the way back up.
val rewrite_bottom_up :
+ f:('a First.t -> 'a First.t) ->
+ g:(('a, 'b) t -> ('a, 'b) t) ->
+ ('a, 'b) t ->
+ ('a, 'b) trewrite_bottom_up specializes fold_pattern so that the result type 'r1 is equal to the type of the nested fixed-point type i.e. 'r1 = 'a First.t and the result type 'r2 is equal to the top-level fixed-point type i.e. 'r2 = ('a,'b) t.
This also means that the function f can be written with our nested fixed-point type 'a First.t as its argument and g can be written with ('a,'b) t as its argument.
val unfold_pattern :
+ f:('r1 -> 'a * 'r1 First.Pattern.t) ->
+ g:('r2 -> 'b * ('r1, 'r2) Pattern.t) ->
+ 'r2 ->
+ ('a, 'b) tunfold_pattern takes a seed value of type 'r2 and uses the function g to generate a tuple of meta-data and a pattern with types 'r1 and 'r2. The functions proceeds by recursively applying g to the contained values of type 'r2 and f to values of type 'r1 finishing when the pattern contains no values of type 'r1 or 'r2.
Make.Xval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bFoldable.Makeval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a X.t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a X.t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a X.t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a X.t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Make2.Xval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cFoldable.Make2val fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) X.t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) X.t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) X.t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) X.t ->
+ boolCommon.FoldableThis module follows the Jane Street organisation and naming conventions for 'standard interfaces' i.e. commonly used signatures; briefly:
Basic defines the _minimal_ set of type and function signatures that a user must provideS defines the _complete_ set of type and functions signatures that will be exposed by any module supporting the standard interface associated with SMake is a functor (i.e. a function from module to module) that takes the user supplied Basic module and returns a completed module with the signature defined by SWhere a standard interface is defined for difference arities of type constructors, the convention is to append the arity to the names of the signatures and functors e.g. Basic2, S2 and Make2
module type Basic = sig ... endThe Basic definition for type constructors with a single type variable.
module type S = sig ... endThe complete module signature for Foldable for types with a single type variable.
module type Basic2 = sig ... endThe Basic definition for type constructors with two type variables.
module type S2 = sig ... endThe complete module signature for Foldable for types with a single type variable.
Foldable.BasicThe Basic definition for type constructors with a single type variable.
This signature just says that you have some type 'a t and a function fold with type:
fold: ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bThis function can be derived using ppx_deriving.
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bFoldable.Basic2The Basic definition for type constructors with two type variables.
val fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cFoldable.SThe complete module signature for Foldable for types with a single type variable.
val fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Foldable.S2The complete module signature for Foldable for types with a single type variable.
val fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolCommon.GensymGenerate fresh (never before used) symbols.
Uses an internal (mutable) counter
Common.ICEInternal compiler errors
An alias of Core.raise_s. This used to do more processing, for now it is preserved just as a nicer marker in the code
Common.PatternA Pattern defines the signature of modules that may be fixed with Fixed.Make and Fixed.Make2.
These signatures ensure that all the operations we want to support on our top level intermediate representations can be defined by the Fixed.Make functors.
Pattern.Sval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
Pattern.S2val fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolCommon.PrettyNamed signatures for types that can be pretty-printed.
Pretty.Sval pp : Stdlib.Format.formatter -> t -> unitPretty.S1val pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitPretty.S2val pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ (Stdlib.Format.formatter -> 'b -> unit) ->
+ Stdlib.Format.formatter ->
+ ('a, 'b) t ->
+ unitMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tMake.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tMake.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpMake.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tMake.Xval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldMake.Metainclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareval empty : tSpecialized.Makemodule X : Unspecializedinclude Ppx_compare_lib.Comparable.S with type t := tinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tMake2.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tMake2.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpMake2.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tMake2.Xval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tFirst.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tFirst.Metainclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareval empty : tFirst.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpFirst.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tMake2.Firstinclude Ppx_compare_lib.Comparable.S with type t := tinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endMake2.Metainclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareval empty : tSpecialized.Make2module X : Unspecialized2type t = (First.Meta.t, Meta.t) X.tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endCommon.SpecializedThis module defines signature and functors used to 'specialize' a fixed-point type that is polymorphic in the type of meta-data to a particular type of meta-data.
This specialization is useful since we end up with a concrete type of kind * (i.e. not a type _constructor_) allowing us to make the type Comparable. In the analysis and optimization code, we work with map's and sets of our IR types a lot and this approach makes the types much nicer to work with.
module type Meta = sig ... endSignature of all meta data used to annotate IRs
module type Unspecialized = sig ... endmodule type Unspecialized2 = sig ... endmodule type S = sig ... endSince the type t is now concrete (i.e. not a type _constructor_) we can construct a Comparable.S giving us Map and Set specialized to the type.
Specialized.MetaSignature of all meta data used to annotate IRs
include Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareval empty : tMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tS.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tS.Metainclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareval empty : tS.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpS.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tSpecialized.SSince the type t is now concrete (i.e. not a type _constructor_) we can construct a Comparable.S giving us Map and Set specialized to the type.
include Ppx_compare_lib.Comparable.S with type t := tinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endSpecialized.Unspecializedval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldSpecialized.Unspecialized2val fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldCommonmodule Fixed : sig ... endThis module defines the signatures and Make functors for the 'fixed point' (or two-level) type we use for our intermediate representations
module Foldable : sig ... endThis module follows the Jane Street organisation and naming conventions for 'standard interfaces' i.e. commonly used signatures; briefly:
module Gensym : sig ... endGenerate fresh (never before used) symbols.
module ICE : sig ... endInternal compiler errors
module Pattern : sig ... endA Pattern defines the signature of modules that may be fixed with Fixed.Make and Fixed.Make2.
module Pretty : sig ... endNamed signatures for types that can be pretty-printed.
module Specialized : sig ... endThis module defines signature and functors used to 'specialize' a fixed-point type that is polymorphic in the type of meta-data to a particular type of meta-data.
Frontend.AstAbstract 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
Our type for identifiers, on which we record a location
val identifier_of_sexp : Sexplib0.Sexp.t -> identifierval sexp_of_identifier : identifier -> Sexplib0.Sexp.tval hash_fold_identifier :
+ Ppx_hash_lib.Std.Hash.state ->
+ identifier ->
+ Ppx_hash_lib.Std.Hash.stateval hash_identifier : identifier -> Ppx_hash_lib.Std.Hash.hash_valueval compare_identifier : identifier -> identifier -> intIndices for array access
val fold_index : ('a -> 'b -> 'c) -> 'd -> 'e index -> 'fval index_of_sexp : 'e. (Sexplib0.Sexp.t -> 'e) -> Sexplib0.Sexp.t -> 'e indexval sexp_of_index : 'e. ('e -> Sexplib0.Sexp.t) -> 'e index -> Sexplib0.Sexp.tval hash_fold_index :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e index ->
+ Ppx_hash_lib.Std.Hash.statetype fun_kind = | StanLib of bool Middle.Fun_kind.suffix| UserDefined of bool Middle.Fun_kind.suffixFront-end function kinds
val fun_kind_of_sexp : Sexplib0.Sexp.t -> fun_kindval sexp_of_fun_kind : fun_kind -> Sexplib0.Sexp.tval hash_fold_fun_kind :
+ Ppx_hash_lib.Std.Hash.state ->
+ fun_kind ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fun_kind : fun_kind -> Ppx_hash_lib.Std.Hash.hash_valuetype ('e, 'f) expression = | TernaryIf of 'e * 'e * 'e| BinOp of 'e * Middle.Operator.t * 'e| PrefixOp of Middle.Operator.t * 'e| PostfixOp of 'e * Middle.Operator.t| Variable of identifier| IntNumeral of string| RealNumeral of string| ImagNumeral of string| FunApp of 'f * identifier * 'e list| CondDistApp of 'f * identifier * 'e list| Promotion of 'e * Middle.UnsizedType.t * Middle.UnsizedType.autodifftype| GetTarget| ArrayExpr of 'e list| RowVectorExpr of 'e list| Paren of 'e| Indexed of 'e * 'e index list| TupleProjection of 'e * int| TupleExpr of 'e listExpression shapes (used for both typed and untyped expressions, where we substitute untyped_expression or typed_expression for 'e
val map_expression :
+ ('a -> 'b) ->
+ ('c -> 'd) ->
+ ('e, 'f) expression ->
+ ('g, 'h) expressionval fold_expression :
+ ('a -> 'b -> 'a) ->
+ ('c -> 'd -> 'e) ->
+ 'f ->
+ ('g, 'h) expression ->
+ 'ival expression_of_sexp :
+ 'e 'f. (Sexplib0.Sexp.t -> 'e) ->
+ (Sexplib0.Sexp.t -> 'f) ->
+ Sexplib0.Sexp.t ->
+ ('e, 'f) expressionval sexp_of_expression :
+ 'e 'f. ('e -> Sexplib0.Sexp.t) ->
+ ('f -> Sexplib0.Sexp.t) ->
+ ('e, 'f) expression ->
+ Sexplib0.Sexp.tval hash_fold_expression :
+ 'e 'f. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'f -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('e, 'f) expression ->
+ Ppx_hash_lib.Std.Hash.stateval compare_expression :
+ 'e 'f. ('e -> 'e -> Core__.Import.int) ->
+ ('f -> 'f -> Core__.Import.int) ->
+ ('e, 'f) expression ->
+ ('e, 'f) expression ->
+ Core__.Import.intval fold_expr_with :
+ ('a -> 'b -> 'c) ->
+ ('d -> 'e -> 'd) ->
+ 'd ->
+ ('f, 'g) expr_with ->
+ 'dval expr_with_of_sexp :
+ 'm 'f. (Sexplib0.Sexp.t -> 'm) ->
+ (Sexplib0.Sexp.t -> 'f) ->
+ Sexplib0.Sexp.t ->
+ ('m, 'f) expr_withval sexp_of_expr_with :
+ 'm 'f. ('m -> Sexplib0.Sexp.t) ->
+ ('f -> Sexplib0.Sexp.t) ->
+ ('m, 'f) expr_with ->
+ Sexplib0.Sexp.tval hash_fold_expr_with :
+ 'm 'f. (Ppx_hash_lib.Std.Hash.state -> 'm -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'f -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('m, 'f) expr_with ->
+ Ppx_hash_lib.Std.Hash.stateUntyped expressions, which have location_spans as meta-data
val map_located_meta : located_meta -> located_metaval fold_located_meta : 'a -> located_meta -> 'bval located_meta_of_sexp : Sexplib0.Sexp.t -> located_metaval sexp_of_located_meta : located_meta -> Sexplib0.Sexp.tval compare_located_meta : located_meta -> located_meta -> intval hash_fold_located_meta :
+ Ppx_hash_lib.Std.Hash.state ->
+ located_meta ->
+ Ppx_hash_lib.Std.Hash.stateval hash_located_meta : located_meta -> Ppx_hash_lib.Std.Hash.hash_valuetype untyped_expression = (located_meta, unit) expr_withval untyped_expression_of_sexp : Sexplib0.Sexp.t -> untyped_expressionval sexp_of_untyped_expression : untyped_expression -> Sexplib0.Sexp.tval compare_untyped_expression :
+ untyped_expression ->
+ untyped_expression ->
+ intval hash_fold_untyped_expression :
+ Ppx_hash_lib.Std.Hash.state ->
+ untyped_expression ->
+ Ppx_hash_lib.Std.Hash.stateval hash_untyped_expression :
+ untyped_expression ->
+ Ppx_hash_lib.Std.Hash.hash_valuetype typed_expr_meta = {loc : Middle.Location_span.t;ad_level : Middle.UnsizedType.autodifftype;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 map_typed_expr_meta : typed_expr_meta -> typed_expr_metaval fold_typed_expr_meta : 'a -> typed_expr_meta -> 'bval typed_expr_meta_of_sexp : Sexplib0.Sexp.t -> typed_expr_metaval sexp_of_typed_expr_meta : typed_expr_meta -> Sexplib0.Sexp.tval compare_typed_expr_meta : typed_expr_meta -> typed_expr_meta -> intval hash_fold_typed_expr_meta :
+ Ppx_hash_lib.Std.Hash.state ->
+ typed_expr_meta ->
+ Ppx_hash_lib.Std.Hash.stateval hash_typed_expr_meta : typed_expr_meta -> Ppx_hash_lib.Std.Hash.hash_valuetype typed_expression = (typed_expr_meta, fun_kind) expr_withval typed_expression_of_sexp : Sexplib0.Sexp.t -> typed_expressionval sexp_of_typed_expression : typed_expression -> Sexplib0.Sexp.tval compare_typed_expression : typed_expression -> typed_expression -> intval hash_fold_typed_expression :
+ Ppx_hash_lib.Std.Hash.state ->
+ typed_expression ->
+ Ppx_hash_lib.Std.Hash.stateval hash_typed_expression :
+ typed_expression ->
+ Ppx_hash_lib.Std.Hash.hash_valueval mk_untyped_expression :
+ expr:((located_meta, 'a) expr_with, 'a) expression ->
+ loc:Middle.Location_span.t ->
+ (located_meta, 'a) expr_withval mk_typed_expression :
+ expr:((typed_expr_meta, 'a) expr_with, 'a) expression ->
+ loc:Middle.Location_span.t ->
+ type_:Middle.UnsizedType.t ->
+ ad_level:Middle.UnsizedType.autodifftype ->
+ (typed_expr_meta, 'a) expr_withval expr_loc_lub :
+ (typed_expr_meta, 'a) expr_with list ->
+ Middle.Location_span.tval expr_ad_lub :
+ (typed_expr_meta, 'a) expr_with list ->
+ Middle.UnsizedType.autodifftype optionLeast upper bound of expression autodiff types
Assignment operators
val assignmentoperator_of_sexp : Sexplib0.Sexp.t -> assignmentoperatorval sexp_of_assignmentoperator : assignmentoperator -> Sexplib0.Sexp.tval hash_fold_assignmentoperator :
+ Ppx_hash_lib.Std.Hash.state ->
+ assignmentoperator ->
+ Ppx_hash_lib.Std.Hash.stateval hash_assignmentoperator :
+ assignmentoperator ->
+ Ppx_hash_lib.Std.Hash.hash_valueval compare_assignmentoperator :
+ assignmentoperator ->
+ assignmentoperator ->
+ intval map_truncation : ('a -> 'b) -> 'c truncation -> 'd truncationval fold_truncation : ('a -> 'b -> 'c) -> 'd -> 'e truncation -> 'fval truncation_of_sexp :
+ 'e. (Sexplib0.Sexp.t -> 'e) ->
+ Sexplib0.Sexp.t ->
+ 'e truncationval sexp_of_truncation :
+ 'e. ('e -> Sexplib0.Sexp.t) ->
+ 'e truncation ->
+ Sexplib0.Sexp.tval hash_fold_truncation :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e truncation ->
+ Ppx_hash_lib.Std.Hash.stateval compare_truncation :
+ 'e. ('e -> 'e -> int) ->
+ 'e truncation ->
+ 'e truncation ->
+ intval fold_printable : ('a -> 'b -> 'c) -> 'd -> 'e printable -> 'fval printable_of_sexp :
+ 'e. (Sexplib0.Sexp.t -> 'e) ->
+ Sexplib0.Sexp.t ->
+ 'e printableval sexp_of_printable :
+ 'e. ('e -> Sexplib0.Sexp.t) ->
+ 'e printable ->
+ Sexplib0.Sexp.tval hash_fold_printable :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e printable ->
+ Ppx_hash_lib.Std.Hash.statetype ('l, 'e) lvalue = | LVariable of identifier| LIndexed of 'l * 'e index list| LTupleProjection of 'l * intval fold_lvalue :
+ ('a -> 'b -> 'c) ->
+ ('d -> 'e -> 'd) ->
+ 'f ->
+ ('g, 'h) lvalue ->
+ 'ival lvalue_of_sexp :
+ 'l 'e. (Sexplib0.Sexp.t -> 'l) ->
+ (Sexplib0.Sexp.t -> 'e) ->
+ Sexplib0.Sexp.t ->
+ ('l, 'e) lvalueval sexp_of_lvalue :
+ 'l 'e. ('l -> Sexplib0.Sexp.t) ->
+ ('e -> Sexplib0.Sexp.t) ->
+ ('l, 'e) lvalue ->
+ Sexplib0.Sexp.tval hash_fold_lvalue :
+ 'l 'e. (Ppx_hash_lib.Std.Hash.state -> 'l -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('l, 'e) lvalue ->
+ Ppx_hash_lib.Std.Hash.statetype 'l lvalue_pack = | LValue of 'l| LTuplePack of {lvals : 'l lvalue_pack list;loc : Middle.Location_span.t;}val map_lvalue_pack : ('a -> 'b) -> 'c lvalue_pack -> 'd lvalue_packval fold_lvalue_pack : ('a -> 'b -> 'c) -> 'd -> 'e lvalue_pack -> 'dval lvalue_pack_of_sexp :
+ 'l. (Sexplib0.Sexp.t -> 'l) ->
+ Sexplib0.Sexp.t ->
+ 'l lvalue_packval sexp_of_lvalue_pack :
+ 'l. ('l -> Sexplib0.Sexp.t) ->
+ 'l lvalue_pack ->
+ Sexplib0.Sexp.tval hash_fold_lvalue_pack :
+ 'l. (Ppx_hash_lib.Std.Hash.state -> 'l -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'l lvalue_pack ->
+ Ppx_hash_lib.Std.Hash.stateval compare_lvalue_pack :
+ 'l. ('l -> 'l -> Core__.Import.int) ->
+ 'l lvalue_pack ->
+ 'l lvalue_pack ->
+ Core__.Import.intval fold_lval_with :
+ ('a -> 'b -> 'a) ->
+ ('c -> 'd -> 'e) ->
+ 'a ->
+ ('f, 'g) lval_with ->
+ 'aval lval_with_of_sexp :
+ 'e 'm. (Sexplib0.Sexp.t -> 'e) ->
+ (Sexplib0.Sexp.t -> 'm) ->
+ Sexplib0.Sexp.t ->
+ ('e, 'm) lval_withval sexp_of_lval_with :
+ 'e 'm. ('e -> Sexplib0.Sexp.t) ->
+ ('m -> Sexplib0.Sexp.t) ->
+ ('e, 'm) lval_with ->
+ Sexplib0.Sexp.tval hash_fold_lval_with :
+ 'e 'm. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'm -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('e, 'm) lval_with ->
+ Ppx_hash_lib.Std.Hash.statetype untyped_lval = (untyped_expression, located_meta) lval_withval untyped_lval_of_sexp : Sexplib0.Sexp.t -> untyped_lvalval sexp_of_untyped_lval : untyped_lval -> Sexplib0.Sexp.tval hash_fold_untyped_lval :
+ Ppx_hash_lib.Std.Hash.state ->
+ untyped_lval ->
+ Ppx_hash_lib.Std.Hash.stateval hash_untyped_lval : untyped_lval -> Ppx_hash_lib.Std.Hash.hash_valueval compare_untyped_lval : untyped_lval -> untyped_lval -> inttype untyped_lval_pack = untyped_lval lvalue_packval untyped_lval_pack_of_sexp : Sexplib0.Sexp.t -> untyped_lval_packval sexp_of_untyped_lval_pack : untyped_lval_pack -> Sexplib0.Sexp.tval compare_untyped_lval_pack : untyped_lval_pack -> untyped_lval_pack -> inttype typed_lval = (typed_expression, typed_expr_meta) lval_withval typed_lval_of_sexp : Sexplib0.Sexp.t -> typed_lvalval sexp_of_typed_lval : typed_lval -> Sexplib0.Sexp.tval hash_fold_typed_lval :
+ Ppx_hash_lib.Std.Hash.state ->
+ typed_lval ->
+ Ppx_hash_lib.Std.Hash.stateval hash_typed_lval : typed_lval -> Ppx_hash_lib.Std.Hash.hash_valueval compare_typed_lval : typed_lval -> typed_lval -> inttype typed_lval_pack = typed_lval lvalue_packval typed_lval_pack_of_sexp : Sexplib0.Sexp.t -> typed_lval_packval sexp_of_typed_lval_pack : typed_lval_pack -> Sexplib0.Sexp.tval compare_typed_lval_pack : typed_lval_pack -> typed_lval_pack -> intval fold_variable : ('a -> 'b -> 'c) -> 'd -> 'e variable -> 'fval variable_of_sexp :
+ 'e. (Sexplib0.Sexp.t -> 'e) ->
+ Sexplib0.Sexp.t ->
+ 'e variableval sexp_of_variable :
+ 'e. ('e -> Sexplib0.Sexp.t) ->
+ 'e variable ->
+ Sexplib0.Sexp.tval hash_fold_variable :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e variable ->
+ Ppx_hash_lib.Std.Hash.statetype ('e, 's, 'l, 'f) statement = | Assignment of {assign_lhs : 'l lvalue_pack;assign_op : assignmentoperator;assign_rhs : 'e;}| NRFunApp of 'f * identifier * 'e list| TargetPE of 'e| JacobianPE of 'e| Tilde of {arg : 'e;distribution : identifier;args : 'e list;truncation : 'e truncation;}| Break| Continue| Return of 'e| ReturnVoid| Print of 'e printable list| Reject of 'e printable list| FatalError of 'e printable list| Skip| IfThenElse of 'e * 's * 's option| While of 'e * 's| For of {loop_variable : identifier;lower_bound : 'e;upper_bound : 'e;loop_body : 's;}| ForEach of identifier * 'e * 's| Profile of string * 's list| Block of 's list| VarDecl of {decl_type : 'e Middle.SizedType.t;transformation : 'e Middle.Transformation.t;is_global : bool;variables : 'e variable list;}| FunDef of {returntype : Middle.UnsizedType.returntype;funname : identifier;arguments : (Middle.UnsizedType.autodifftype
+ * Middle.UnsizedType.t
+ * identifier)
+ list;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 fold_statement :
+ ('a -> 'b -> 'a) ->
+ ('c -> 'd -> 'c) ->
+ ('e -> 'f -> 'e) ->
+ ('g -> 'h -> 'i) ->
+ 'j ->
+ ('k, 'l, 'm, 'n) statement ->
+ 'oval statement_of_sexp :
+ 'e 's 'l 'f. (Sexplib0.Sexp.t -> 'e) ->
+ (Sexplib0.Sexp.t -> 's) ->
+ (Sexplib0.Sexp.t -> 'l) ->
+ (Sexplib0.Sexp.t -> 'f) ->
+ Sexplib0.Sexp.t ->
+ ('e, 's, 'l, 'f) statementval 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.tval hash_fold_statement :
+ 'e 's 'l 'f. (Ppx_hash_lib.Std.Hash.state ->
+ 'e ->
+ Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 's -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'l -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'f -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('e, 's, 'l, 'f) statement ->
+ Ppx_hash_lib.Std.Hash.stateStatement return types which we will decorate statements with during type checking:
Complete corresponds to statements that exit the function (return or error) in every branchIncomplete corresponds to statements which pass control flow to following statements in at least some branchesNonlocalControlFlow 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 statement_returntype_of_sexp : Sexplib0.Sexp.t -> statement_returntypeval sexp_of_statement_returntype : statement_returntype -> Sexplib0.Sexp.tval hash_fold_statement_returntype :
+ Ppx_hash_lib.Std.Hash.state ->
+ statement_returntype ->
+ Ppx_hash_lib.Std.Hash.stateval hash_statement_returntype :
+ statement_returntype ->
+ Ppx_hash_lib.Std.Hash.hash_valueval compare_statement_returntype :
+ statement_returntype ->
+ statement_returntype ->
+ inttype ('e, 'm, 'l, 'f) statement_with = {stmt : ('e, ('e, 'm, 'l, 'f) statement_with, 'l, 'f) statement;smeta : 'm;}val map_statement_with :
+ ('e -> 'a) ->
+ ('m -> 'b) ->
+ ('l -> 'c) ->
+ ('f -> 'd) ->
+ ('e0, 'm0, 'l0, 'f0) statement_with ->
+ ('g, 'h, 'i, 'j) statement_withval fold_statement_with :
+ ('a -> 'b -> 'a) ->
+ ('c -> 'd -> 'e) ->
+ ('a -> 'f -> 'a) ->
+ ('a -> 'g -> 'a) ->
+ 'a ->
+ ('h, 'i, 'j, 'k) statement_with ->
+ 'aval statement_with_of_sexp :
+ 'e 'm 'l 'f. (Sexplib0.Sexp.t -> 'e) ->
+ (Sexplib0.Sexp.t -> 'm) ->
+ (Sexplib0.Sexp.t -> 'l) ->
+ (Sexplib0.Sexp.t -> 'f) ->
+ Sexplib0.Sexp.t ->
+ ('e, 'm, 'l, 'f) statement_withval 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.tval compare_statement_with :
+ 'e 'm 'l 'f. ('e -> 'e -> Core__.Import.int) ->
+ ('m -> 'm -> Core__.Import.int) ->
+ ('l -> 'l -> Core__.Import.int) ->
+ ('f -> 'f -> Core__.Import.int) ->
+ ('e, 'm, 'l, 'f) statement_with ->
+ ('e, 'm, 'l, 'f) statement_with ->
+ Core__.Import.intval hash_fold_statement_with :
+ 'e 'm 'l 'f. (Ppx_hash_lib.Std.Hash.state ->
+ 'e ->
+ Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'm -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'l -> Ppx_hash_lib.Std.Hash.state) ->
+ (Ppx_hash_lib.Std.Hash.state -> 'f -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ ('e, 'm, 'l, 'f) statement_with ->
+ Ppx_hash_lib.Std.Hash.statetype untyped_statement =
+ (untyped_expression, located_meta, untyped_lval, unit) statement_withUntyped statements, which have location_spans as meta-data
val untyped_statement_of_sexp : Sexplib0.Sexp.t -> untyped_statementval sexp_of_untyped_statement : untyped_statement -> Sexplib0.Sexp.tval compare_untyped_statement : untyped_statement -> untyped_statement -> intval hash_fold_untyped_statement :
+ Ppx_hash_lib.Std.Hash.state ->
+ untyped_statement ->
+ Ppx_hash_lib.Std.Hash.stateval hash_untyped_statement :
+ untyped_statement ->
+ Ppx_hash_lib.Std.Hash.hash_valueval mk_untyped_statement :
+ stmt:
+ (untyped_expression,
+ (untyped_expression, located_meta, untyped_lval, unit) statement_with,
+ untyped_lval,
+ unit)
+ statement ->
+ loc:Middle.Location_span.t ->
+ untyped_statementval map_stmt_typed_located_meta :
+ stmt_typed_located_meta ->
+ stmt_typed_located_metaval stmt_typed_located_meta_of_sexp :
+ Sexplib0.Sexp.t ->
+ stmt_typed_located_metaval sexp_of_stmt_typed_located_meta :
+ stmt_typed_located_meta ->
+ Sexplib0.Sexp.tval compare_stmt_typed_located_meta :
+ stmt_typed_located_meta ->
+ stmt_typed_located_meta ->
+ intval hash_fold_stmt_typed_located_meta :
+ Ppx_hash_lib.Std.Hash.state ->
+ stmt_typed_located_meta ->
+ Ppx_hash_lib.Std.Hash.stateval hash_stmt_typed_located_meta :
+ stmt_typed_located_meta ->
+ Ppx_hash_lib.Std.Hash.hash_valuetype typed_statement =
+ (typed_expression, stmt_typed_located_meta, typed_lval, fun_kind)
+ statement_withTyped 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 typed_statement_of_sexp : Sexplib0.Sexp.t -> typed_statementval sexp_of_typed_statement : typed_statement -> Sexplib0.Sexp.tval compare_typed_statement : typed_statement -> typed_statement -> intval hash_fold_typed_statement :
+ Ppx_hash_lib.Std.Hash.state ->
+ typed_statement ->
+ Ppx_hash_lib.Std.Hash.stateval hash_typed_statement : typed_statement -> Ppx_hash_lib.Std.Hash.hash_valueval 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_withProgram shapes, where we obtain types of programs if we substitute typed or untyped statements for 's
and comment_type = | LineComment of string * Middle.Location_span.t| Include of string * Middle.Location_span.t| BlockComment of string list * Middle.Location_span.t| Separator of Middle.Location.tSeparator 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
*)val map_comment_type : comment_type -> comment_typeval fold_block : ('a -> 'b -> 'a) -> 'c -> 'd block -> 'eval fold_comment_type : 'a -> comment_type -> 'bval fold_program : ('a -> 'b -> 'a) -> 'c -> 'd program -> 'eval block_of_sexp : 's. (Sexplib0.Sexp.t -> 's) -> Sexplib0.Sexp.t -> 's blockval comment_type_of_sexp : Sexplib0.Sexp.t -> comment_typeval program_of_sexp :
+ 's. (Sexplib0.Sexp.t -> 's) ->
+ Sexplib0.Sexp.t ->
+ 's programval sexp_of_block : 's. ('s -> Sexplib0.Sexp.t) -> 's block -> Sexplib0.Sexp.tval sexp_of_comment_type : comment_type -> Sexplib0.Sexp.tval sexp_of_program :
+ 's. ('s -> Sexplib0.Sexp.t) ->
+ 's program ->
+ Sexplib0.Sexp.tval hash_fold_block :
+ 's. (Ppx_hash_lib.Std.Hash.state -> 's -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 's block ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_comment_type :
+ Ppx_hash_lib.Std.Hash.state ->
+ comment_type ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_program :
+ 's. (Ppx_hash_lib.Std.Hash.state -> 's -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 's program ->
+ Ppx_hash_lib.Std.Hash.stateval hash_comment_type : comment_type -> Ppx_hash_lib.Std.Hash.hash_valueval compare_comment_type : comment_type -> comment_type -> intval get_stmts : 'a block option -> 'b listtype untyped_program = untyped_statement programUntyped programs (before type checking)
val untyped_program_of_sexp : Sexplib0.Sexp.t -> untyped_programval sexp_of_untyped_program : untyped_program -> Sexplib0.Sexp.tval compare_untyped_program : untyped_program -> untyped_program -> inttype typed_program = typed_statement programTyped programs (after type checking)
val typed_program_of_sexp : Sexplib0.Sexp.t -> typed_programval sexp_of_typed_program : typed_program -> Sexplib0.Sexp.tval compare_typed_program : typed_program -> typed_program -> intval untyped_expression_of_typed_expression :
+ typed_expression ->
+ untyped_expressionForgetful function from typed to untyped expressions
val untyped_lvalue_of_typed_lvalue : typed_lval -> untyped_lvalval untyped_lvalue_of_typed_lvalue_pack :
+ typed_lval lvalue_pack ->
+ untyped_lval lvalue_packval untyped_statement_of_typed_statement :
+ (typed_expression, stmt_typed_located_meta, typed_lval, 'a) statement_with ->
+ (untyped_expression, located_meta, untyped_lval, unit) statement_withForgetful function from typed to untyped statements
val untyped_program_of_typed_program : typed_program -> untyped_programForgetful function from typed to untyped programs
val extract_ids : ('a, 'b) expr_with -> identifier Base__List.tval lvalue_of_expr_opt :
+ untyped_expression ->
+ ((located_meta, unit) expr_with, located_meta) lval_with lvalue_pack optionval type_of_arguments :
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t * 'a) list ->
+ Middle.UnsizedType.argumentlistval get_loc_lvalue_pack : typed_lval lvalue_pack -> Middle.Location_span.tval get_loc_dt :
+ untyped_expression Middle.SizedType.t ->
+ Middle.Location.t optionval get_loc_tf :
+ untyped_expression Middle.Transformation.t ->
+ Middle.Location.t optionval get_first_loc : untyped_statement -> Middle.Location.tFrontend.Ast_to_MirTranslate from the AST to the MIR
val gather_declarations :
+ Ast.typed_statement Ast.block option ->
+ (Middle.Expr.Typed.t Middle.SizedType.t
+ * Middle.Expr.Typed.t Middle.Transformation.t
+ * string)
+ listval trans_prog : string -> Ast.typed_program -> Middle.Program.Typed.tFrontend.CanonicalizeRe-write ASTs to remove deprecated features and clean up extra parenthesis, etc
Flags to enable or disable certain kinds of canonicalization. NB: inline_includes is controlled by the --canonicalize argument to stanc, but it consumed by the pretty-printer, not this module.
val legacy : canonicalizer_settingsEquivalent to what --print-canonical did before these settings were available
val none : canonicalizer_settingsval canonicalize_program :
+ Ast.typed_program ->
+ canonicalizer_settings ->
+ Ast.typed_program"Canonicalize" the program by removing deprecations, adding or removing parenthesis and braces, etc.
Frontend.DebuggingSome helpers for debugging
val ast_to_string : Ast.untyped_program -> stringval ast_logger : Ast.untyped_program -> unitControls whether a decorated AST gets printed after the semantic check
val typed_ast_to_string : Ast.typed_program -> stringval typed_ast_logger : Ast.typed_program -> unitFrontend.Deprecation_analysisUtilities for emitting deprecation warnings and finding proper replacements for deprecated features
val collect_warnings : Ast.typed_program -> Warnings.t listval remove_unneeded_forward_decls : Ast.typed_program -> Ast.typed_programFrontend.EnvironmentType environments used during typechecking. Maps from strings to function or variable information
Origin blocks, to keep track of where variables are declared
Information available for each variable
type info = {type_ : Middle.UnsizedType.t;kind : [ `Variable of varinfo
+ | `UserDeclared of Middle.Location_span.t
+ | `StanMath
+ | `UserDefined ];}val stan_math_environment : tA type environment which contains the Stan math library functions
val add :
+ t ->
+ string ->
+ Middle.UnsizedType.t ->
+ [ `UserDeclared of Middle.Location_span.t
+ | `StanMath
+ | `UserDefined
+ | `Variable of varinfo ] ->
+ tAdd a new item to the type environment. Does not overwrite existing, but shadows
val mem : t -> string -> boolval nearest_ident : t -> string -> string optionThe nearest identifier by edit distance, capped at edit distance 3 (if one exists)
Frontend.ErrorsSome plumbing for our compiler errors
type syntax_error = | Lexing of Middle.Location.t| UnexpectedEOF of Middle.Location.t| Include of string * Middle.Location.t| Parsing of string * Middle.Location_span.tOur type of syntax error information
exception SyntaxError of syntax_errorException for Syntax Errors
exception SemanticError of Semantic_error.tException SemanticError (loc, msg) indicates a semantic error with message msg, occurring at location loc.
type t = | FileNotFound of string| Syntax_error of syntax_error| Semantic_error of Semantic_error.t| DebugDataError of Middle.Location_span.t * stringval pp : ?printed_filename:string -> ?code:string -> t Fmt.tPretty-printer for error type t. Replace occurances of filename from locations with printed_filename, if supplied. If code is supplied, read context from that string. Otherwise, it will attempt to open the original file.
val to_string : t -> stringFormat an error t as a string. Should only be used in testing! For user facing code, prefer pp
val pp_semantic_error :
+ ?printed_filename:string ->
+ ?code:string ->
+ Stdlib.Format.formatter ->
+ Semantic_error.t ->
+ unitA semantic error message used when handling a SemanticError
Frontend.Include_filesval include_provider : t Core.refWhere and how to look for #include-d files
Frontend.InfoImplementation of the --info option which outputs on the standard output a JSON object containing information about the model.
The JSON object has a field inputs, parameters, transformed
+ parameters, and generated quantities containing a dictionary where each entry corresponds to a variable in respectively the data, parameters, transformed parameters, and generated
+ quantities blocks. To each variable is associated an object with two fields:
type: the base type of the variable ("int" or "real").dimensions: the number of dimensions (0 for a scalar, 1 for a vector or row vector, etc.).The JSON object also have the fields stanlib_calls and distributions containing the name of the standard library functions called and distributions used.
val info : Ast.typed_program -> stringFrontend.Input_warningsA module to contain the mutable state used to track warnings from the parser and lexer.
As something of a hack, Input_warnings keeps track of which warnings the lexer has emitted as a form of hidden state, which must be initialized and collected.
val collect : unit -> Warnings.t listReturns all of the warnings issued since init was called.
val add_warning : Middle.Location_span.t -> string -> unitAdd a generic warning string to the current list
Frontend.Lexerval token : Stdlib.Lexing.lexbuf -> Parser.tokenval __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> Parser.tokenFrontend.ParseSome complicated stuff to get the custom syntax errors out of Menhir's Incremental API
val parse_file :
+ (Stdlib.Lexing.position ->
+ Ast.untyped_program Parser.MenhirInterpreter.checkpoint) ->
+ string ->
+ (Ast.untyped_program, Errors.t) Core.result * Warnings.t listA helper function to take a parser, a filename and produce an AST. Under the hood, it takes care of Menhir's custom syntax error messages.
val parse_string :
+ (Stdlib.Lexing.position ->
+ Ast.untyped_program Parser.MenhirInterpreter.checkpoint) ->
+ string ->
+ (Ast.untyped_program, Errors.t) Core.result * Warnings.t listParser.Incrementalval program :
+ Stdlib.Lexing.position ->
+ (Ast.untyped_expression, Ast.located_meta, Ast.untyped_lval, unit)
+ Ast.statement_with
+ Ast.program
+ MenhirInterpreter.checkpointval functions_only :
+ Stdlib.Lexing.position ->
+ Ast.untyped_statement Ast.program MenhirInterpreter.checkpointParser.MenhirInterpreterinclude MenhirLib.IncrementalEngine.INCREMENTAL_ENGINE with type token = tokentype token = tokenval offer :
+ 'a checkpoint ->
+ (token
+ * MenhirLib.IncrementalEngine.position
+ * MenhirLib.IncrementalEngine.position) ->
+ 'a checkpointval resume : ?strategy:strategy -> 'a checkpoint -> 'a checkpointtype supplier =
+ unit ->
+ token
+ * MenhirLib.IncrementalEngine.position
+ * MenhirLib.IncrementalEngine.positionval loop : ?strategy:strategy -> supplier -> 'a checkpoint -> 'aval loop_handle :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval loop_handle_undo :
+ ('a -> 'answer) ->
+ ('a checkpoint -> 'a checkpoint -> 'answer) ->
+ supplier ->
+ 'a checkpoint ->
+ 'answerval shifts : 'a checkpoint -> 'a env optionval acceptable :
+ 'a checkpoint ->
+ token ->
+ MenhirLib.IncrementalEngine.position ->
+ boolval number : 'a lr1state -> intval production_index : production -> intval find_production : int -> productiontype stack = element MenhirLib.General.streamval current_state_number : 'a env -> intval positions :
+ 'a env ->
+ MenhirLib.IncrementalEngine.position * MenhirLib.IncrementalEngine.positionval env_has_default_reduction : 'a env -> boolval state_has_default_reduction : 'a lr1state -> boolval force_reduction : production -> 'a env -> 'a envval input_needed : 'a env -> 'a checkpointFrontend.Parsertype token = | WHILE| VOID| VECTOR| UPPER| UNREACHABLE| UNITVECTOR| TUPLE| TRUNCATE| TRANSPOSE| TRANSFORMEDPARAMETERSBLOCK| TRANSFORMEDDATABLOCK| TIMESASSIGN| TIMES| TILDE| TARGET| STRINGLITERAL of string| STOCHASTICROWMATRIX| STOCHASTICCOLUMNMATRIX| SIMPLEX| SEMICOLON| RPAREN| ROWVECTOR| RETURN| REJECT| REALNUMERAL of string| REAL| RBRACK| RBRACE| RABRACK| QMARK| PROFILE| PRINT| POSITIVEORDERED| PLUSASSIGN| PLUS| PARAMETERSBLOCK| ORDERED| OR| OFFSET| NEQUALS| MULTIPLIER| MODULO| MODELBLOCK| MINUSASSIGN| MINUS| MATRIX| LPAREN| LOWER| LEQ| LDIVIDE| LBRACK| LBRACE| LABRACK| JACOBIAN| INTNUMERAL of string| INT| IN| IMAGNUMERAL of string| IF| IDIVIDE| IDENTIFIER of string| HAT| GEQ| GENERATEDQUANTITIESBLOCK| FUNCTIONBLOCK| FOR| FATAL_ERROR| EQUALS| EOF| ELTTIMESASSIGN| ELTTIMES| ELTPOW| ELTDIVIDEASSIGN| ELTDIVIDE| ELSE| DOTNUMERAL of string| DIVIDEASSIGN| DIVIDE| DATABLOCK| COVMATRIX| CORRMATRIX| CONTINUE| COMPLEXVECTOR| COMPLEXROWVECTOR| COMPLEXMATRIX| COMPLEX| COMMA| COLON| CHOLESKYFACTORCOV| CHOLESKYFACTORCORR| BREAK| BAR| BANG| ASSIGN| ARRAY| ANDval program :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ (Ast.untyped_expression, Ast.located_meta, Ast.untyped_lval, unit)
+ Ast.statement_with
+ Ast.programval functions_only :
+ (Stdlib.Lexing.lexbuf -> token) ->
+ Stdlib.Lexing.lexbuf ->
+ Ast.untyped_statement Ast.programmodule MenhirInterpreter : sig ... endmodule Incremental : sig ... endFrontend.Parsing_errorsFrontend.PreprocessorPreprocessor for handling include directives
val location_of_position : Stdlib.Lexing.position -> Middle.Location.tval location_span_of_positions :
+ (Stdlib.Lexing.position * Stdlib.Lexing.position) ->
+ Middle.Location_span.tUpdate the lex_start_p the lexing buffers on the stack. This solves an issue where a parser which started with one lexbuf but is finishing with another can have the wrong information
val add_comment : Ast.comment_type -> unitval get_comments : unit -> Ast.comment_type listRestore to a previous lexing buffer (assumes that one exists) and updates positions accordingly.
Frontend.Pretty_print_progPretty print a complete Stan program.
This module relies on Parser to be able to run a "sanity check" on the output of the pretty printer, confirming that the output is a valid Stan program and matches the input program.
However, the parser relies on some pretty printing functions to be able to produce nicer error messages, hence the split between Pretty_printing and this module.
val pretty_print_typed_program :
+ ?bare_functions:bool ->
+ ?line_length:int ->
+ ?inline_includes:bool ->
+ ?strip_comments:bool ->
+ Ast.typed_program ->
+ stringFrontend.Pretty_printingSome helpers to produce nice error messages and for auto-formatting Stan programs
val comments : Ast.comment_type list Core.refTo avoid cluttering the AST, comments are not associated with any particular AST node but instead come in a separate list. The pretty printer uses the AST nodes' location metadata to insert whitespace and comments. The comment list is stored in a global state that is accessed by set_comments, get_comments, and skip_comments.
val skipped :
+ ([ `Block | `Include | `Line ] * string list * Middle.Location_span.t) list
+ Core.refval set_comments :
+ ?inline_includes:bool ->
+ ?strip_comments:bool ->
+ Ast.comment_type list ->
+ unitval get_comments :
+ Middle.Location.t ->
+ ([> `Block | `Include | `Line ] * string list * Middle.Location_span.t) listval get_comments_until_separator :
+ Middle.Location.t ->
+ ([> `Block | `Include | `Line ] * string list * Middle.Location_span.t) listval skip_comments : Middle.Location.t -> unitval remaining_comments :
+ unit ->
+ ([ `Block | `Include | `Line ] * string list * Middle.Location_span.t)
+ Base__List.tval should_skip : Middle.Location.t -> boolChecks if something should be skipped based on the print_included setting
val pp_space :
+ bool ->
+ Stdlib.Format.formatter ->
+ (Middle.Location.t * Middle.Location.t) ->
+ unitval pp_comment :
+ Stdlib.Format.formatter ->
+ ([< `Block | `Include | `Line ] * string list * Middle.Location_span.t) ->
+ unitval pp_spacing :
+ ?newline:bool ->
+ Middle.Location.t option ->
+ Middle.Location.t option ->
+ Stdlib.Format.formatter ->
+ ([< `Block | `Include | `Line Include Line ]
+ * string list
+ * Middle.Location_span.t)
+ list ->
+ unitval pp_comments_spacing :
+ bool ->
+ ('a ->
+ ([< `Block | `Include | `Line Block ]
+ * string list
+ * Middle.Location_span.t)
+ list) ->
+ Stdlib.Format.formatter ->
+ 'b ->
+ unitval pp_unsizedtype : Middle.UnsizedType.t Fmt.tval pp_autodifftype :
+ Stdlib.Format.formatter ->
+ Middle.UnsizedType.autodifftype ->
+ unitval pp_returntype :
+ Stdlib.Format.formatter ->
+ Middle.UnsizedType.returntype ->
+ unitval pp_identifier : Stdlib.Format.formatter -> Ast.identifier -> unitval pp_operator : Stdlib.Format.formatter -> Middle.Operator.t -> unitval pp_list_of :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ ('a0 -> Middle.Location_span.t) ->
+ Stdlib.Format.formatter ->
+ ('a1 list * Middle.Location_span.t) ->
+ unitval pp_index : Ast.untyped_expression Ast.index Fmt.tval pp_list_of_indices :
+ Stdlib.Format.formatter ->
+ Ast.untyped_expression Ast.index list ->
+ unitval pp_expression : Stdlib.Format.formatter -> Ast.untyped_expression -> unitval pp_list_of_expression :
+ Stdlib.Format.formatter ->
+ (Ast.untyped_expression list * Middle.Location_span.t) ->
+ unitval pp_lvalue :
+ Stdlib.Format.formatter ->
+ ((Ast.located_meta, unit) Ast.expr_with, Ast.located_meta) Ast.lval_with
+ Ast.lvalue_pack ->
+ unitval pp_assignmentoperator :
+ Stdlib.Format.formatter ->
+ Ast.assignmentoperator ->
+ unitval pp_truncation :
+ Stdlib.Format.formatter ->
+ Ast.untyped_expression Ast.truncation ->
+ unitval pp_printable :
+ Stdlib.Format.formatter ->
+ Ast.untyped_expression Ast.printable ->
+ unitval pp_list_of_printables :
+ Stdlib.Format.formatter ->
+ Ast.untyped_expression Ast.printable list ->
+ unitval pp_bracketed_transform :
+ Stdlib.Format.formatter ->
+ Ast.untyped_expression Middle.Transformation.t ->
+ unitval pp_transformed_type :
+ (Ast.untyped_expression Middle.SizedType.t
+ * Ast.untyped_expression Middle.Transformation.t)
+ Fmt.tval pp_indent_unless_block :
+ Stdlib.Format.formatter ->
+ (Ast.untyped_statement * Middle.Location.t) ->
+ unitval pp_recursive_ifthenelse :
+ ((Ast.untyped_expression, Ast.located_meta, Ast.untyped_lval, unit)
+ Ast.statement_with
+ * Middle.Location.t)
+ Fmt.tThis function helps write chained if-then-else-if-... blocks correctly. Without it, each IfThenElse would trigger a new vbox in front of the if, adding spaces for each level of IfThenElse.
val pp_statement : Ast.untyped_statement Fmt.tval pp_args :
+ Stdlib.Format.formatter ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t * Ast.identifier) ->
+ unitval pp_list_of_statements :
+ ((Ast.untyped_expression, Ast.located_meta, Ast.untyped_lval, unit)
+ Ast.statement_with
+ list
+ * Middle.Location_span.t)
+ Fmt.tval pp_typed_expression :
+ Stdlib.Format.formatter ->
+ Ast.typed_expression ->
+ unitFrontend.Promotionmodule UnsizedType = Middle.UnsizedTypetype t = | NoPromotion| IntToReal| ToVar| ToComplexVar| IntToComplex| RealToComplex| TuplePromotion of t listType to represent promotions in the typechecker. This can be used to return information about how to promote expressions for use in Ast.Promotion
val t_of_sexp : Sexplib0.Sexp.t -> tval sexp_of_t : t -> Sexplib0.Sexp.tval scalarize : UnsizedType.t -> UnsizedType.tOur promotion nodes only store the scalar type to promote, e.g to promote a tuple(array int) to a tuple(array real), we store tuple(real), not tuple(array real)
val promote_unsized_type :
+ UnsizedType.t ->
+ UnsizedType.autodifftype ->
+ t ->
+ UnsizedType.t * UnsizedType.autodifftypeGet the UnsizedType.t which is the result of promoting a given type. See promote for the version which promotes expressions directly.
val promote_inner :
+ Ast.typed_expression ->
+ t ->
+ (Ast.typed_expr_meta, Ast.fun_kind) Ast.expr_withval promote :
+ (Ast.typed_expr_meta, Ast.fun_kind) Ast.expr_with ->
+ t ->
+ (Ast.typed_expr_meta, Ast.fun_kind) Ast.expr_withval promote_list :
+ (Ast.typed_expr_meta, Ast.fun_kind) Ast.expr_with list ->
+ t list ->
+ (Ast.typed_expr_meta, Ast.fun_kind) Ast.expr_with listval get_type_promotion_exn :
+ (UnsizedType.autodifftype * UnsizedType.t) ->
+ (UnsizedType.autodifftype * UnsizedType.t) ->
+ tGet the promotion needed to make the second type into the first. Types NEED to have previously been checked to be promotable or else a fatal error will be thrown.
val promotion_cost : t -> Core.Int.tCalculate the "cost"/number of promotions performed. Used to disambiguate function signatures
Frontend.Semantic_errorval pp : Stdlib.Format.formatter -> t -> unitval location : t -> Middle.Location_span.tval invalid_return :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval mismatched_array_types :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval invalid_row_vector_types :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval invalid_matrix_types : Middle.Location_span.t -> Middle.UnsizedType.t -> tval int_expected :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t ->
+ tval int_or_real_expected :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t ->
+ tval int_intarray_or_range_expected :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval int_or_real_container_expected :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval scalar_or_type_expected :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval array_vector_rowvector_matrix_expected :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_assignment :
+ Middle.Location_span.t ->
+ Middle.Operator.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_ternary_if :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval returning_fn_expected_nonreturning_found :
+ Middle.Location_span.t ->
+ string ->
+ tval returning_fn_expected_nonfn_found : Middle.Location_span.t -> string -> tval returning_fn_expected_undeclaredident_found :
+ Middle.Location_span.t ->
+ string ->
+ string option ->
+ tval returning_fn_expected_undeclared_dist_suffix_found :
+ Middle.Location_span.t ->
+ (string * string) ->
+ tval returning_fn_expected_wrong_dist_suffix_found :
+ Middle.Location_span.t ->
+ (string * string) ->
+ tval illtyped_reduce_sum_not_array :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_reduce_sum_slice :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_reduce_sum :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t list ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ SignatureMismatch.function_mismatch ->
+ tval ambiguous_function_promotion :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t list option ->
+ (Middle.UnsizedType.returntype
+ * (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list)
+ list ->
+ tval illtyped_variadic :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t list ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ Middle.UnsizedType.t ->
+ SignatureMismatch.function_mismatch ->
+ tval nonreturning_fn_expected_returning_found :
+ Middle.Location_span.t ->
+ string ->
+ tval nonreturning_fn_expected_nonfn_found :
+ Middle.Location_span.t ->
+ string ->
+ tval nonreturning_fn_expected_undeclaredident_found :
+ Middle.Location_span.t ->
+ string ->
+ string option ->
+ tval illtyped_fn_app :
+ Middle.Location_span.t ->
+ string ->
+ (SignatureMismatch.signature_error list * bool) ->
+ Middle.UnsizedType.t list ->
+ tval illtyped_binary_op :
+ Middle.Location_span.t ->
+ Middle.Operator.t ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_prefix_op :
+ Middle.Location_span.t ->
+ Middle.Operator.t ->
+ Middle.UnsizedType.t ->
+ tval illtyped_postfix_op :
+ Middle.Location_span.t ->
+ Middle.Operator.t ->
+ Middle.UnsizedType.t ->
+ tval tuple_index_invalid_index : Middle.Location_span.t -> int -> int -> tval tuple_index_not_tuple : Middle.Location_span.t -> Middle.UnsizedType.t -> tval not_indexable : Middle.Location_span.t -> Middle.UnsizedType.t -> int -> tval ident_is_keyword : Middle.Location_span.t -> string -> tval ident_is_model_name : Middle.Location_span.t -> string -> tval ident_is_stanmath_name : Middle.Location_span.t -> string -> tval ident_in_use : Middle.Location_span.t -> string -> tval ident_not_in_scope : Middle.Location_span.t -> string -> string option -> tval invalid_decl_rng_fn : Middle.Location_span.t -> tval invalid_rng_fn : Middle.Location_span.t -> tval invalid_unnormalized_fn : Middle.Location_span.t -> tval udf_is_unnormalized_fn : Middle.Location_span.t -> string -> tval ident_has_unnormalized_suffix : Middle.Location_span.t -> string -> tval conditional_notation_not_allowed : Middle.Location_span.t -> tval conditioning_required : Middle.Location_span.t -> tval not_printable : Middle.Location_span.t -> tval empty_array : Middle.Location_span.t -> tval empty_tuple : Middle.Location_span.t -> tval bad_int_literal : Middle.Location_span.t -> tval cannot_assign_to_read_only : Middle.Location_span.t -> string -> tval cannot_assign_to_global : Middle.Location_span.t -> string -> tval cannot_assign_function :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.t ->
+ tval cannot_assign_to_multiindex : Middle.Location_span.t -> tval cannot_assign_duplicate_unpacking :
+ Middle.Location_span.t ->
+ Ast.untyped_lval list ->
+ tval cannot_access_assigning_var : Middle.Location_span.t -> string list -> tval invalid_tilde_pdf_or_pmf : Middle.Location_span.t -> tval invalid_tilde_cdf_or_ccdf : Middle.Location_span.t -> string -> tval invalid_tilde_no_such_dist : Middle.Location_span.t -> string -> bool -> tval target_plusequals_outside_model_or_logprob : Middle.Location_span.t -> tval jacobian_plusequals_not_allowed : Middle.Location_span.t -> tval invalid_truncation_cdf_or_ccdf :
+ Middle.Location_span.t ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ tval break_outside_loop : Middle.Location_span.t -> tval continue_outside_loop : Middle.Location_span.t -> tval expression_return_outside_returning_fn : Middle.Location_span.t -> tval void_outside_nonreturning_fn : Middle.Location_span.t -> tval non_data_variable_size_decl : Middle.Location_span.t -> tval non_int_bounds : Middle.Location_span.t -> tval complex_transform : Middle.Location_span.t -> tval transformed_params_int : Middle.Location_span.t -> tval fn_overload_rt_only :
+ Middle.Location_span.t ->
+ string ->
+ Middle.UnsizedType.returntype ->
+ Middle.UnsizedType.returntype ->
+ tval fn_decl_redefined :
+ Middle.Location_span.t ->
+ string ->
+ stan_math:bool ->
+ Middle.UnsizedType.t ->
+ tval fn_decl_exists : Middle.Location_span.t -> string -> tval fn_decl_without_def : Middle.Location_span.t -> string -> tval fn_decl_needs_block : Middle.Location_span.t -> tval non_real_prob_fn_def : Middle.Location_span.t -> tval prob_density_non_real_variate :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t option ->
+ tval prob_mass_non_int_variate :
+ Middle.Location_span.t ->
+ Middle.UnsizedType.t option ->
+ tval duplicate_arg_names : Middle.Location_span.t -> tval incompatible_return_types : Middle.Location_span.t -> tFrontend.SignatureMismatchtype type_mismatch = private | DataOnlyError| TypeMismatch of Middle.UnsizedType.t * Middle.UnsizedType.t * details optionand details = private | SuffixMismatch of unit Middle.Fun_kind.suffix * unit Middle.Fun_kind.suffix| ReturnTypeMismatch of Middle.UnsizedType.returntype
+ * Middle.UnsizedType.returntype| InputMismatch of function_mismatchtype signature_error =
+ (Middle.UnsizedType.returntype
+ * (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list)
+ * function_mismatchtype ('unique, 'error) generic_match_result = | UniqueMatch of 'unique| AmbiguousMatch of (Middle.UnsizedType.returntype
+ * (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t)
+ list)
+ list| SignatureErrors of 'errortype match_result =
+ (Middle.UnsizedType.returntype
+ * (bool Middle.Fun_kind.suffix ->
+ Ast.fun_kind)
+ * Promotion.t list,
+ signature_error list * bool)
+ generic_match_resultThe match result for general (non-variadic) functions
val check_of_same_type_mod_conv :
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.t ->
+ (Promotion.t, type_mismatch) Core.resultval check_compatible_arguments_mod_conv :
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ (Promotion.t list, function_mismatch) Core.resultval unique_minimum_promotion :
+ ('a * Promotion.t list) list ->
+ ('a * Promotion.t list, 'a list option) Core.resultval matching_function :
+ Environment.t ->
+ string ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ match_resultSearches for a function of the given name which can support the required argument types. Requires a unique minimum option under type promotion
val matching_stanlib_function :
+ string ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ match_resultSame as matching_function but requires specifically that the function be from StanMath (uses Environment.stan_math_environment)
val check_variadic_args :
+ allow_lpdf:bool ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ Middle.UnsizedType.t ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ (Middle.UnsizedType.t * Promotion.t list,
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list
+ * function_mismatch)
+ Core.resultCheck variadic function arguments. If a match is found, returns Ok of the function type and a list of promotions (see promote) If none is found, returns Error of the list of args and a function_mismatch.
val pp_signature_mismatch :
+ Stdlib.Format.formatter ->
+ (string
+ * Middle.UnsizedType.t list
+ * (((Middle.UnsizedType.returntype
+ * (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list)
+ * function_mismatch)
+ list
+ * bool)) ->
+ unitval pp_math_lib_assignmentoperator_sigs :
+ Stdlib.Format.formatter ->
+ (Middle.UnsizedType.t * Middle.Operator.t) ->
+ unitval compare_errors : function_mismatch -> function_mismatch -> intval compare_match_results : match_result -> match_result -> intFrontend.Typecheckera type/semantic checker for Stan ASTs
Functions which begin with "check_" return a typed version of their input Functions which begin with "verify_" return unit if a check succeeds, or else throw an Frontend.Errors.SemanticError exception. Other functions which begin with "infer"/"calculate" vary. Usually they return a value, but a few do have error conditions.
All Error.SemanticError excepetions are caught by check_program which turns the ast or exception into a Result.t for external usage
A type environment Frontend.Environment.t is used to hold variables and functions, including Stan math functions. This is a functional map, meaning it is handled immutably.
val check_program_exn :
+ Ast.untyped_program ->
+ Ast.typed_program * Warnings.t listType check a full Stan program. Can raise Errors.SemanticError
val check_program :
+ Ast.untyped_program ->
+ (Ast.typed_program * Warnings.t list, Semantic_error.t) Stdlib.resultThe safe version of check_program_exn. This catches all Errors.SemanticError exceptions and converts them into a Result.t
val operator_stan_math_return_type :
+ Middle.Operator.t ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ (Middle.UnsizedType.returntype * Promotion.t list) optionval stan_math_return_type :
+ string ->
+ (Middle.UnsizedType.autodifftype * Middle.UnsizedType.t) list ->
+ Middle.UnsizedType.returntype optionA reference to hold the model name. Relevant for checking variable clashes and used in code generation.
Frontend.WarningsUsed for user-facing warning messages
type t = Middle.Location_span.t * stringval pp : ?printed_filename:string -> t Fmt.tval pp_warnings : ?printed_filename:string -> t list Fmt.tFrontendmodule Ast : sig ... endAbstract 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.
module Ast_to_Mir : sig ... endmodule Canonicalize : sig ... endRe-write ASTs to remove deprecated features and clean up extra parenthesis, etc
module Debugging : sig ... endSome helpers for debugging
module Deprecation_analysis : sig ... endUtilities for emitting deprecation warnings and finding proper replacements for deprecated features
module Environment : sig ... endType environments used during typechecking. Maps from strings to function or variable information
module Errors : sig ... endSome plumbing for our compiler errors
module Include_files : sig ... endmodule Info : sig ... endImplementation of the --info option which outputs on the standard output a JSON object containing information about the model.
module Input_warnings : sig ... endA module to contain the mutable state used to track warnings from the parser and lexer.
module Lexer : sig ... endmodule Parse : sig ... endSome complicated stuff to get the custom syntax errors out of Menhir's Incremental API
module Parser : sig ... endmodule Parsing_errors : sig ... endmodule Preprocessor : sig ... endPreprocessor for handling include directives
module Pretty_print_prog : sig ... endPretty print a complete Stan program.
module Pretty_printing : sig ... endSome helpers to produce nice error messages and for auto-formatting Stan programs
module Promotion : sig ... endmodule Semantic_error : sig ... endmodule SignatureMismatch : sig ... endmodule Typechecker : sig ... enda type/semantic checker for Stan ASTs
module Warnings : sig ... endUsed for user-facing warning messages
Fixed.Patternval sexp_of_litType : litType -> Sexplib0.Sexp.tval litType_of_sexp : Sexplib0.Sexp.t -> litTypeval hash_fold_litType :
+ Ppx_hash_lib.Std.Hash.state ->
+ litType ->
+ Ppx_hash_lib.Std.Hash.stateval hash_litType : litType -> Ppx_hash_lib.Std.Hash.hash_valuetype 'a t = | Var of string| Lit of litType * string| FunApp of 'a Fun_kind.t * 'a list| TernaryIf of 'a * 'a * 'a| EAnd of 'a * 'a| EOr of 'a * 'a| Indexed of 'a * 'a Index.t list| Promotion of 'a * UnsizedType.t * UnsizedType.autodifftype| TupleProjection of 'a * intinclude Sexplib0.Sexpable.S1 with type 'a t := 'a tinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tinclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tinclude Common.Pattern.S with type 'a t := 'a tval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Common.Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
include Common.Pretty.S1 with type 'a t := 'a tval pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitExpr.Fixedmodule Pattern : sig ... endinclude Common.Fixed.S with module Pattern := Patternval fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'binclude Ppx_compare_lib.Comparable.S1 with type 'a t := 'a tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S1 with type 'a t := 'a tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldinclude Common.Foldable.S with type 'a t := 'a tval fold_left : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'bLeft associative fold of a data structure; this is the same as the function derived from [@@deriving fold] but with labelled arguments
val fold_right : f:('a -> 'b -> 'b) -> init:'b -> 'a t -> 'bRight associative fold of a data structure
val any : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether any element of the data structure satisfies the supplied predicate. The optional argument init specifies the starting value and defaults to false.
val all : pred:('a -> bool) -> ?init:bool -> 'a t -> boolTest whether all elements of the the data structure satify the supplied predicate. The optional argument init specifies the starting value and defaults to true.
include Common.Pretty.S1 with type 'a t := 'a tval pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t ->
+ unitfold_pattern traverses the data structure from the bottom up replacing the original meta data of type 'a with some result type 'r and combines the result values on the way back up. For example, given a pattern with the following type:
type 'a pattern = Leaf of string | Branch of 'a * 'a
we can use fold_pattern to calculate the maximum depth of data structure obtained by fixing the pattern type:
let max_depth t =
+ let f = function
+ | meta , Leaf _ -> 1
+ | meta , Branch(left_depth,right_depth) ->
+ 1 + (max left_depth right_depth)
+ in
+ fold_pattern ~f tNote that the function 'f' supplied to fold_pattern accepts a tuple rather than our type 'a t since the type of the pattern has been transformed to 'r t Pattern.t and is no longer 'compatible' with the original type of meta data 'a. That is, a tuple ('a * 'b t Pattern.t) has two type variables where as 'a t has one.
rewrite_bottom_up specializes fold_pattern so that the result type 'r is equal to the type of our fixed-point data structure i.e. 'r = 'a t. This also means that the function f can be written with our fixed-point type 'a t as its argument.
unfold builds a fixed-point data structure from the top down. Starting with a user-supplied seed of type 'r, unfold recursively applies the function f yielding a tuple of meta-data and pattern with elements of type 'r to which f is further applied.
The unfold terminates when a pattern element which does not carry an 'r is reached.
As with fold_pattern the function f returns a tuple of meta-data and pattern rather than our record type since, in general, 'r =/= 'a t.
Expr.Helpersval int : int -> Typed.tval float : float -> Typed.tval complex : (float * float) -> Typed.tval str : string -> Typed.tval variable : string -> Typed.tval zero : Typed.tval one : Typed.tval unary_op : Operator.t -> Typed.t -> Typed.tval binop : Typed.t -> Operator.t -> Typed.t -> Typed.tval binop_list : Typed.t list -> Operator.t -> default:Typed.t -> Typed.tval row_vector : float list -> Typed.tval vector : float list -> Typed.tval matrix : float list list -> Typed.tval complex_row_vector : (float * float) list -> Typed.tval complex_vector : (float * float) list -> Typed.tval loop_bottom : Typed.tval internal_funapp :
+ 'a Fixed.t Internal_fun.t ->
+ 'a Fixed.t list ->
+ 'a ->
+ 'a Fixed.tval contains_fn_kind :
+ ('a Fixed.t Fun_kind.t -> bool) ->
+ ?init:bool ->
+ 'a Fixed.t ->
+ boolval infer_type_of_indexed : UnsizedType.t -> 'a Index.t list -> UnsizedType.tMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tTyped.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tTyped.Metaval create :
+ type_:UnsizedType.t ->
+ loc:Location_span.t ->
+ adlevel:UnsizedType.autodifftype ->
+ unit ->
+ tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Sexplib0.Sexpable.S with type t := tinclude Ppx_hash_lib.Hashable.S with type t := tinclude Common.Specialized.Meta with type t := tinclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitval empty : tTyped.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpTyped.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tExpr.Typedmodule Meta : sig ... endinclude Common.Specialized.S
+ with module Meta := Meta
+ and type t = Meta.t Fixed.tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endval type_of : t -> UnsizedType.tval loc_of : t -> Location_span.tval adlevel_of : t -> UnsizedType.autodifftypeval fun_arg : t -> UnsizedType.autodifftype * UnsizedType.tMiddle.ExprMIR types and modules corresponding to the expressions of the language
Middle.Flag_varsMiddle.Fun_kindTypes for function kinds, e.g. StanLib or UserDefined, and function suffix types, e.g. foo_ldfp, bar_lp
val fold_suffix : ('a -> 'b -> 'c) -> 'd -> 'e suffix -> 'fval hash_fold_suffix :
+ 'propto. (Ppx_hash_lib.Std.Hash.state ->
+ 'propto ->
+ Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'propto suffix ->
+ Ppx_hash_lib.Std.Hash.stateval suffix_of_sexp :
+ 'propto. (Sexplib0.Sexp.t -> 'propto) ->
+ Sexplib0.Sexp.t ->
+ 'propto suffixval sexp_of_suffix :
+ 'propto. ('propto -> Sexplib0.Sexp.t) ->
+ 'propto suffix ->
+ Sexplib0.Sexp.ttype 'e t = | StanLib of string * bool suffix * Mem_pattern.t| CompilerInternal of 'e Internal_fun.t| UserDefined of string * bool suffixval fold : ('a -> 'b -> 'a) -> 'c -> 'd t -> 'eval t_of_sexp : 'e. (Sexplib0.Sexp.t -> 'e) -> Sexplib0.Sexp.t -> 'e tval sexp_of_t : 'e. ('e -> Sexplib0.Sexp.t) -> 'e t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e t ->
+ Ppx_hash_lib.Std.Hash.stateval suffix_from_name : string -> bool suffixval pp : 'a Fmt.t -> Stdlib.Format.formatter -> 'b t -> unitval collect_exprs : 'a t -> 'b listMiddle.IndexTypes of indexing operations
val fold : ('a -> 'b -> 'c) -> 'd -> 'e t -> 'fval t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a tval sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'a t ->
+ Ppx_hash_lib.Std.Hash.stateval pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'b t ->
+ unitval pp_indices :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'a t list ->
+ unitval bounds : 'a t -> 'b listval apply : default:'b -> merge:('c -> 'd -> 'e) -> ('a -> 'f) -> 'a0 t -> 'gApply an op over the Index types inner expressions.
val folder :
+ string Core.Set.Poly.t ->
+ (string Core.Set.Poly.t -> 'a -> string Core.Set.Poly.t) ->
+ 'a0 t ->
+ string Core.Set.Poly.tMiddle.Internal_funLanguage functions defined internally by the compiler
type 'expr t = | FnLength| FnMakeArray| FnMakeTuple| FnMakeRowVec| FnNegInf| FnReadData| FnReadDeserializer| FnReadParam of {constrain : 'expr Transformation.t;dims : 'expr list;mem_pattern : Mem_pattern.t;}| FnWriteParam of {unconstrain_opt : 'expr Transformation.t option;var : 'expr;}| FnValidateSize| FnValidateSizeSimplex| FnValidateSizeUnitVector| FnCheck of {trans : 'expr Transformation.t;var_name : string;var : 'expr;}| FnPrint| FnReject| FnFatalError| FnResizeToMatch| FnNaN| FnDeepCopy| FnReadWriteEventsOpenCL of stringval fold : ('a -> 'b -> 'a) -> 'c -> 'd t -> 'eval t_of_sexp : 'expr. (Sexplib0.Sexp.t -> 'expr) -> Sexplib0.Sexp.t -> 'expr tval sexp_of_t : 'expr. ('expr -> Sexplib0.Sexp.t) -> 'expr t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'expr. (Ppx_hash_lib.Std.Hash.state -> 'expr -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'expr t ->
+ Ppx_hash_lib.Std.Hash.stateval to_string : ?expr_to_string:('a -> Sexplib0.Sexp.t) -> 'a t -> stringval pp : 'a Fmt.t -> Stdlib.Format.formatter -> 'a0 t -> unitval can_side_effect : 'a t -> boolval collect_exprs : 'a t -> 'b listMiddle.LocationStoring locations in the original source
Source code locations
val t_of_sexp : Sexplib0.Sexp.t -> tval sexp_of_t : t -> Sexplib0.Sexp.tval hash_fold_t :
+ Ppx_hash_lib.Std.Hash.state ->
+ t ->
+ Ppx_hash_lib.Std.Hash.stateval hash : t -> Ppx_hash_lib.Std.Hash.hash_valueval pp_context_list : Stdlib.Format.formatter -> (string list * t) -> unitval context_to_string : (unit -> string list) -> t -> string optionTurn the given location into a string holding the code of that location. Code is retrieved by calling context_cb, which may do IO. Exceptions in the callback or in the creation of the string (possible if the context is incorrectly too short for the given location) return None
val empty : tval to_string :
+ ?printed_filename:string ->
+ ?print_file:bool ->
+ ?print_line:bool ->
+ t ->
+ stringFormat the location for error messaging.
If printed_filename is passed, it replaces the highest-level name and leaves the filenames of included files intact.
Location_span.Comparatorval comparator : (t, comparator_witness) Core__Comparator.comparatorMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = Comparator.comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tLocation_span.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tLocation_span.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = Comparator.comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpLocation_span.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tMiddle.Location_spanDelimited locations in source code
val t_of_sexp : Sexplib0.Sexp.t -> tval sexp_of_t : t -> Sexplib0.Sexp.tval hash_fold_t :
+ Ppx_hash_lib.Std.Hash.state ->
+ t ->
+ Ppx_hash_lib.Std.Hash.stateval hash : t -> Ppx_hash_lib.Std.Hash.hash_valueval empty : tval to_string : ?printed_filename:string -> t -> stringRender a location_span as a string
module Comparator : sig ... endinclude module type of struct include Comparator endtype comparator_witness = Comparator.comparator_witnessinclude sig ... endval comparator : (t, Comparator.comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endMiddle.Mem_pattern* This type represents whether or not an autodiff type can be represented * as an Array of Structs (AoS) or as a Struct of Arrays. This applies to * matrices, vectors, row vectors, and arrays of those types. * In the C++ this allows us to swap out matrix types from an * Eigen::Matrix<stan::math::var_value<double>, Rows, Cols> to an * stan::math::var_value<Eigen::Matrix<double, Rows, Cols>>. * (fyi a var in the C++ code is an alias for var_value<double>) * *
val fold : 'a -> t -> 'bval t_of_sexp : Sexplib0.Sexp.t -> tval sexp_of_t : t -> Sexplib0.Sexp.tval hash_fold_t :
+ Ppx_hash_lib.Std.Hash.state ->
+ t ->
+ Ppx_hash_lib.Std.Hash.stateval hash : t -> Ppx_hash_lib.Std.Hash.hash_valueval pp : Stdlib.Format.formatter -> t -> unitMiddle.OperatorUtilities for Stan's built in operators
val t_of_sexp : Sexplib0.Sexp.t -> tval sexp_of_t : t -> Sexplib0.Sexp.tval hash_fold_t :
+ Ppx_hash_lib.Std.Hash.state ->
+ t ->
+ Ppx_hash_lib.Std.Hash.stateval hash : t -> Ppx_hash_lib.Std.Hash.hash_valueval is_cmp : t -> boolval pp : Stdlib.Format.formatter -> t -> unitval to_string : t -> stringval of_string_opt : string -> t optionProgram.Numberedtype nonrec t = (Expr.Typed.t, Stmt.Numbered.t, int) tval pp :
+ Stdlib.Format.formatter ->
+ (Expr.Typed.t, Stmt.Numbered.t, 'a) t ->
+ unitval sexp_of_t :
+ (Expr.Typed.t, Stmt.Numbered.t, Core__.Import.int) t ->
+ Sexplib0.Sexp.tval t_of_sexp :
+ Sexplib0.Sexp.t ->
+ (Expr.Typed.t, Stmt.Numbered.t, Core__.Import.int) tProgram.TypedPrograms with typed expressions and locations
type nonrec t = (Expr.Typed.t, Stmt.Located.t, Location_span.t) tval pp :
+ Stdlib.Format.formatter ->
+ (Expr.Typed.t, Stmt.Located.t, 'a) t ->
+ unitval sexp_of_t :
+ (Expr.Typed.t, Stmt.Located.t, Location_span.t) t ->
+ Sexplib0.Sexp.tval t_of_sexp :
+ Sexplib0.Sexp.t ->
+ (Expr.Typed.t, Stmt.Located.t, Location_span.t) tMiddle.ProgramDefines the core of the MIR
type fun_arg_decl = (UnsizedType.autodifftype * string * UnsizedType.t) listval fun_arg_decl_of_sexp : Sexplib0.Sexp.t -> fun_arg_declval sexp_of_fun_arg_decl : fun_arg_decl -> Sexplib0.Sexp.tval hash_fold_fun_arg_decl :
+ Ppx_hash_lib.Std.Hash.state ->
+ fun_arg_decl ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fun_arg_decl : fun_arg_decl -> Ppx_hash_lib.Std.Hash.hash_valuetype 'a fun_def = {fdrt : UnsizedType.returntype;fdname : string;fdsuffix : unit Fun_kind.suffix;fdargs : (UnsizedType.autodifftype * string * UnsizedType.t) list;fdbody : 'a option;fdloc : Location_span.t;}val fold_fun_def : ('a -> 'b -> 'c) -> 'd -> 'e fun_def -> 'fval hash_fold_fun_def :
+ 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'a fun_def ->
+ Ppx_hash_lib.Std.Hash.stateval fun_def_of_sexp :
+ 'a. (Sexplib0.Sexp.t -> 'a) ->
+ Sexplib0.Sexp.t ->
+ 'a fun_defval sexp_of_fun_def :
+ 'a. ('a -> Sexplib0.Sexp.t) ->
+ 'a fun_def ->
+ Sexplib0.Sexp.tval io_block_of_sexp : Sexplib0.Sexp.t -> io_blockval sexp_of_io_block : io_block -> Sexplib0.Sexp.tval hash_fold_io_block :
+ Ppx_hash_lib.Std.Hash.state ->
+ io_block ->
+ Ppx_hash_lib.Std.Hash.stateval hash_io_block : io_block -> Ppx_hash_lib.Std.Hash.hash_valuetype 'e outvar = {out_unconstrained_st : 'e SizedType.t;out_constrained_st : 'e SizedType.t;out_block : io_block;out_trans : 'e Transformation.t;}val fold_outvar : ('a -> 'b -> 'a) -> 'c -> 'd outvar -> 'eval outvar_of_sexp :
+ 'e. (Sexplib0.Sexp.t -> 'e) ->
+ Sexplib0.Sexp.t ->
+ 'e outvarval sexp_of_outvar :
+ 'e. ('e -> Sexplib0.Sexp.t) ->
+ 'e outvar ->
+ Sexplib0.Sexp.tval hash_fold_outvar :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e outvar ->
+ Ppx_hash_lib.Std.Hash.statetype ('a, 'b, 'm) t = {functions_block : 'b fun_def list;input_vars : (string * 'm * 'a SizedType.t) list;prepare_data : 'b list;log_prob : 'b list;reverse_mode_log_prob : 'b list;generate_quantities : 'b list;transform_inits : 'b list;unconstrain_array : 'b list;output_vars : (string * 'm * 'a outvar) list;prog_name : string;prog_path : string;}val fold :
+ ('a -> 'b -> 'a) ->
+ ('c -> 'd -> 'c) ->
+ ('e -> 'f -> 'g) ->
+ 'h ->
+ ('i, 'j, 'k) t ->
+ 'lval t_of_sexp :
+ 'a 'b 'm. (Sexplib0.Sexp.t -> 'a) ->
+ (Sexplib0.Sexp.t -> 'b) ->
+ (Sexplib0.Sexp.t -> 'm) ->
+ Sexplib0.Sexp.t ->
+ ('a, 'b, 'm) tval sexp_of_t :
+ 'a 'b 'm. ('a -> Sexplib0.Sexp.t) ->
+ ('b -> Sexplib0.Sexp.t) ->
+ ('m -> Sexplib0.Sexp.t) ->
+ ('a, 'b, 'm) t ->
+ Sexplib0.Sexp.tval pp_fun_arg_decl :
+ Stdlib.Format.formatter ->
+ (UnsizedType.autodifftype * string * UnsizedType.t) ->
+ unitval pp_fun_def :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ Stdlib.Format.formatter ->
+ 'b fun_def ->
+ unitval pp_io_block : Stdlib.Format.formatter -> io_block -> unitval pp_output_var :
+ 'a Fmt.t ->
+ Stdlib.Format.formatter ->
+ (string * 'b * 'c outvar) ->
+ unitval pp_input_var :
+ 'a Fmt.t ->
+ Stdlib.Format.formatter ->
+ (string * 'b * 'a SizedType.t) ->
+ unitval pp_input_vars :
+ 'a Fmt.t ->
+ Stdlib.Format.formatter ->
+ (string * 'b * 'a SizedType.t) list ->
+ unitval pp_output_vars :
+ 'a Fmt.t ->
+ Stdlib.Format.formatter ->
+ (string * 'b * 'a outvar) list ->
+ unitval pp :
+ 'a Fmt.t ->
+ 'b Fmt.t ->
+ Stdlib.Format.formatter ->
+ ('c, 'd, 'e) t ->
+ unitmodule Typed : sig ... endPrograms with typed expressions and locations
module Numbered : sig ... endMiddle.SizedTypeTypes which have a concrete size associated, e.g. vector[n]
type 'a t = | SInt| SReal| SComplex| SVector of Mem_pattern.t * 'a| SRowVector of Mem_pattern.t * 'a| SMatrix of Mem_pattern.t * 'a * 'a| SComplexVector of 'a| SComplexRowVector of 'a| SComplexMatrix of 'a * 'a| SArray of 'a t * 'a| STuple of 'a t listval fold : ('a -> 'b -> 'c) -> 'd -> 'e t -> 'dval t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a tval sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'a t ->
+ Ppx_hash_lib.Std.Hash.stateval pp : 'a Fmt.t -> 'b t Fmt.tval to_unsized : 'a t -> UnsizedType.tval get_dims_io :
+ Expr.Typed.t t ->
+ Middle__Expr.Typed.Meta.t Middle__Expr.Fixed.t listGet the dimensions with respect to sizes needed for IO. Note: The main difference from get_dims is complex, where this function treats the complex type as a dual number. Note: Tuples are treated as scalars by this function due to the inherent assumption of rectangularity. Carefully consider new usages and use io_size when possible.
val io_size :
+ Middle__Expr.Typed.Meta.t Middle__Expr.Fixed.t t ->
+ Middle__Expr.Typed.Meta.t Middle__Expr.Fixed.tval get_dims : 'a t -> 'b listGet the dimensions of an object. Note: Tuples are treated as scalars by this function due to the inherent assumption of rectangularity. Carefully consider new usages!
val is_recursive_container : 'a t -> bool* Check whether a SizedType holds indexable SizedTypes.
Return a type's array dimensions and the type inside the (possibly nested) array
Return a type's dimensions and inner scalar. Differs from get_array_dims in that this also breaks down vectors or matrices, so a SVector d is returned as (SReal, [d]) rather than (SVector d, [])
val contains_tuple : 'a t -> boolval is_complex_type : 'a t -> boolval get_mem_pattern : 'a t -> Mem_pattern.t* Return the mem_pattern of the SizedType
val modify_sizedtype_mem : Mem_pattern.t -> 'a t -> 'a tval has_mem_pattern : 'a t -> boolMiddle.Stan_math_signaturesThis module stores a table of all signatures from the Stan math C++ library which are exposed to Stan, and some helper functions for dealing with those signatures.
type fun_arg = UnsizedType.autodifftype * UnsizedType.tFunction arguments are represented by their type an autodiff type. This is AutoDiffable for everything except arguments marked with the data keyword
type signature = UnsizedType.returntype * fun_arg list * Mem_pattern.tSignatures consist of a return type, a list of arguments, and a flag for whether or not those arguments can be Struct of Arrays objects
val stan_math_signatures : (string, signature list) Core.Hashtbl.tMapping from names to signature(s) of functions
type variadic_signature = {return_type : UnsizedType.t;control_args : fun_arg list;required_fn_rt : UnsizedType.t;required_fn_args : fun_arg list;}val stan_math_variadic_signatures : (string, variadic_signature) Core.Hashtbl.tMapping from names to description of a variadic function.
Note that these function names cannot be overloaded, and usually require customized code-gen in the backend.
Equivalent to Hashtbl.mem stan_math_variadic_signatures s
Pretty printers
val pp_math_sig : signature Fmt.tval pp_fkind :
+ Ppx_deriving_runtime.Format.formatter ->
+ fkind ->
+ Ppx_deriving_runtime.unitval show_fkind : fkind -> Ppx_deriving_runtime.stringval distributions :
+ (fkind list * string * dimensionality list * Mem_pattern.t) listThe distribution families exposed by the math library
Helpers for dealing with operators as signatures
val operator_to_stan_math_fns : Operator.t -> string listval pretty_print_math_lib_operator_sigs : Operator.t -> string listval make_assignmentoperator_stan_math_signatures : Operator.t -> signature listSpecial functions for the variadic signatures exposed
val reduce_sum_slice_types : UnsizedType.t listFixed.Patterntype ('a, 'b) t = | Assignment of 'a lvalue * UnsizedType.t * 'a| TargetPE of 'a| JacobianPE of 'a| NRFunApp of 'a Fun_kind.t * 'a list| Break| Continue| Return of 'a option| Skip| IfElse of 'a * 'b * 'b option| While of 'a * 'b| For of {}| Profile of string * 'b list| Block of 'b list| SList of 'b list| Decl of {decl_adtype : UnsizedType.autodifftype;decl_id : string;decl_type : 'a Type.t;initialize : 'a decl_init;}val sexp_of_lvalue : ('e -> Sexplib0.Sexp.t) -> 'e lvalue -> Sexplib0.Sexp.tval sexp_of_lbase : ('e -> Sexplib0.Sexp.t) -> 'e lbase -> Sexplib0.Sexp.tval sexp_of_decl_init :
+ ('a -> Sexplib0.Sexp.t) ->
+ 'a decl_init ->
+ Sexplib0.Sexp.tval lvalue_of_sexp : (Sexplib0.Sexp.t -> 'e) -> Sexplib0.Sexp.t -> 'e lvalueval lbase_of_sexp : (Sexplib0.Sexp.t -> 'e) -> Sexplib0.Sexp.t -> 'e lbaseval decl_init_of_sexp :
+ (Sexplib0.Sexp.t -> 'a) ->
+ Sexplib0.Sexp.t ->
+ 'a decl_initval hash_fold_lvalue :
+ (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e lvalue ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_lbase :
+ (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e lbase ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_decl_init :
+ (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'a decl_init ->
+ Ppx_hash_lib.Std.Hash.stateinclude Common.Pattern.S2 with type ('a, 'b) t := ('a, 'b) tval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Common.Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolinclude Common.Pretty.S2 with type ('a, 'b) t := ('a, 'b) tval pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ (Stdlib.Format.formatter -> 'b -> unit) ->
+ Stdlib.Format.formatter ->
+ ('a, 'b) t ->
+ unitStmt.Fixedmodule Pattern : sig ... endinclude Common.Fixed.S2
+ with module First = Expr.Fixed
+ and module Pattern := Patternmodule First = Expr.Fixedval fold : ('c -> 'a -> 'c) -> ('c -> 'b -> 'c) -> 'c -> ('a, 'b) t -> 'cinclude Ppx_compare_lib.Comparable.S2 with type ('a, 'b) t := ('a, 'b) tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'b Base__Ppx_compare_lib.compare ->
+ ('a, 'b) t Base__Ppx_compare_lib.compareinclude Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) tval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'b Base__Ppx_hash_lib.hash_fold ->
+ ('a, 'b) t Base__Ppx_hash_lib.hash_foldinclude Common.Foldable.S2 with type ('a, 'b) t := ('a, 'b) tval fold_left :
+ f:('c -> 'a -> 'c) ->
+ g:('c -> 'b -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval fold_right :
+ f:('a -> 'c -> 'c) ->
+ g:('b -> 'c -> 'c) ->
+ init:'c ->
+ ('a, 'b) t ->
+ 'cval any :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolval all :
+ pred_first:('a -> bool) ->
+ pred_second:('b -> bool) ->
+ ?init:bool ->
+ ('a, 'b) t ->
+ boolinclude Common.Pretty.S2 with type ('a, 'b) t := ('a, 'b) tval pp :
+ (Stdlib.Format.formatter -> 'a -> unit) ->
+ (Stdlib.Format.formatter -> 'b -> unit) ->
+ Stdlib.Format.formatter ->
+ ('a, 'b) t ->
+ unitval fold_pattern :
+ f:(('a * 'r1 First.Pattern.t) -> 'r1) ->
+ g:(('b * ('r1, 'r2) Pattern.t) -> 'r2) ->
+ ('a, 'b) t ->
+ 'r2fold_pattern traverses the data structure from the bottom up replacing the original meta data of First with type 'a with some result type 'r1 and the meta data at this level withtype 'b to another result type 'r2 and combines the result values on the way back up.
val rewrite_bottom_up :
+ f:('a First.t -> 'a First.t) ->
+ g:(('a, 'b) t -> ('a, 'b) t) ->
+ ('a, 'b) t ->
+ ('a, 'b) trewrite_bottom_up specializes fold_pattern so that the result type 'r1 is equal to the type of the nested fixed-point type i.e. 'r1 = 'a First.t and the result type 'r2 is equal to the top-level fixed-point type i.e. 'r2 = ('a,'b) t.
This also means that the function f can be written with our nested fixed-point type 'a First.t as its argument and g can be written with ('a,'b) t as its argument.
val unfold_pattern :
+ f:('r1 -> 'a * 'r1 First.Pattern.t) ->
+ g:('r2 -> 'b * ('r1, 'r2) Pattern.t) ->
+ 'r2 ->
+ ('a, 'b) tunfold_pattern takes a seed value of type 'r2 and uses the function g to generate a tuple of meta-data and a pattern with types 'r1 and 'r2. The functions proceeds by recursively applying g to the contained values of type 'r2 and f to values of type 'r1 finishing when the pattern contains no values of type 'r1 or 'r2.
Stmt.Helpersval temp_vars :
+ Expr.Typed.t list ->
+ Located.t list * Expr.Typed.t list * (unit -> unit)val ensure_var :
+ (Expr.Typed.t -> 'a -> Located.t) ->
+ Expr.Typed.t ->
+ 'a ->
+ Located.tval internal_nrfunapp :
+ 'a Fixed.First.t Internal_fun.t ->
+ 'a Fixed.First.t list ->
+ 'b ->
+ ('a, 'b) Fixed.tval contains_fn_kind :
+ ('a Fixed.First.t Fun_kind.t -> bool) ->
+ ?init:bool ->
+ ('a, 'b) Fixed.t ->
+ boolval mk_for :
+ Expr.Typed.t ->
+ (Expr.Typed.t -> Located.t) ->
+ Location_span.t ->
+ Located.tval mk_nested_for :
+ Expr.Typed.t list ->
+ (Expr.Typed.t list -> Located.t) ->
+ Location_span.t ->
+ Located.tval mk_for_iteratee :
+ Expr.Typed.t ->
+ (Expr.Typed.t -> Located.t) ->
+ Expr.Typed.t ->
+ Location_span.t ->
+ Located.tval for_each :
+ (Expr.Typed.t -> Located.t) ->
+ Expr.Typed.t ->
+ Location_span.t ->
+ Located.tval for_scalar :
+ Expr.Typed.t SizedType.t ->
+ (Expr.Typed.t SizedType.t -> Expr.Typed.t -> Located.t) ->
+ Expr.Typed.t ->
+ Location_span.t ->
+ Located.tval for_scalar_inv :
+ Expr.Typed.t SizedType.t ->
+ (Expr.Typed.t SizedType.t -> Expr.Typed.t -> Located.t) ->
+ Expr.Typed.t ->
+ Location_span.t ->
+ Located.tval assign_indexed :
+ UnsizedType.t ->
+ 'b Fixed.First.t Fixed.Pattern.lvalue ->
+ 'a ->
+ ('b Expr.Fixed.t -> 'b Expr.Fixed.t) ->
+ 'b Expr.Fixed.t ->
+ ('b, 'a) Fixed.tval get_lhs_name : 'a Fixed.Pattern.lvalue -> stringThe name of the lhs. This adds "." and an index to tuple projections
val lvariable : string -> 'e Fixed.Pattern.lvalueval lvalue_of_expr_opt :
+ 'e Expr.Fixed.t ->
+ 'e Expr.Fixed.t Fixed.Pattern.lvalue optionval expr_of_lvalue :
+ 'e Expr.Fixed.t Fixed.Pattern.lvalue ->
+ meta:'e ->
+ 'e Expr.Fixed.tval map_lhs_variable :
+ f:(string -> string) ->
+ 'e Fixed.Pattern.lvalue ->
+ 'e Fixed.Pattern.lvalueval lhs_indices : 'e Fixed.Pattern.lvalue -> 'e Index.t listval lhs_variable : 'e Fixed.Pattern.lvalue -> stringThis gets the innermost name of the variable. It differs from get_lhs_name in that tuple projections do not add their indices here.
val lvalue_base_reference : 'e Fixed.Pattern.lvalue -> 'e Fixed.Pattern.lvalueReduce an lvalue down to its "base reference", which is a variable with maximum tuple indices after it. For example:
x[1,23] -> x x.11,2.23.3 -> x.1 x.1.21,23.3 -> x.1.2
Map.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tLocated.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tLocated.Metatype t = Location_span.tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Sexplib0.Sexpable.S with type t := tinclude Ppx_hash_lib.Hashable.S with type t := tinclude Common.Specialized.Meta with type t := tinclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitval empty : tLocated.Non_recursiveLocated.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpLocated.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tStmt.Locatedmodule Meta : sig ... endinclude Common.Specialized.S
+ with module Meta := Meta
+ and type t = (Expr.Typed.Meta.t, Meta.t) Fixed.ttype t = (Expr.Typed.Meta.t, Meta.t) Fixed.tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endval loc_of : t -> Location_span.tmodule Non_recursive : sig ... endMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tNumbered.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tNumbered.Metainclude Ppx_compare_lib.Comparable.S with type t := tinclude Sexplib0.Sexpable.S with type t := tinclude Ppx_hash_lib.Hashable.S with type t := tinclude Common.Specialized.Meta with type t := tinclude Ppx_compare_lib.Comparable.S with type t := tval compare : t Base__Ppx_compare_lib.compareinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitval empty : tval from_int : int -> tNumbered.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpNumbered.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tStmt.Numberedmodule Meta : sig ... endinclude Common.Specialized.S
+ with module Meta := Meta
+ and type t = (Expr.Typed.Meta.t, Meta.t) Fixed.ttype t = (Expr.Typed.Meta.t, Meta.t) Fixed.tinclude Ppx_compare_lib.Comparable.S with type t := tinclude Common.Pretty.S with type t := tval pp : Stdlib.Format.formatter -> t -> unitinclude Core.Comparable.S
+ with type t := t
+ and type comparator_witness := comparator_witnessval comparator : (t, comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endMiddle.StmtMIR types and modules corresponding to the statements of the language
module Fixed : sig ... endmodule Located : sig ... endmodule Numbered : sig ... endmodule Helpers : sig ... endMiddle.TransformationTransformations (constraints) for global variable declarations
type 'e t = | Identity| Lower of 'e| Upper of 'e| LowerUpper of 'e * 'e| Offset of 'e| Multiplier of 'e| OffsetMultiplier of 'e * 'e| Ordered| PositiveOrdered| Simplex| UnitVector| CholeskyCorr| CholeskyCov| Correlation| Covariance| StochasticRow| StochasticColumn| TupleTransformation of 'e t listTypes of transformations. Polymorphic type is filled in with an expression fixed-point, e.g. Frontend.Ast.typed_expression
val fold : ('a -> 'b -> 'c) -> 'd -> 'e t -> 'dval t_of_sexp : 'e. (Sexplib0.Sexp.t -> 'e) -> Sexplib0.Sexp.t -> 'e tval sexp_of_t : 'e. ('e -> Sexplib0.Sexp.t) -> 'e t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'e. (Ppx_hash_lib.Std.Hash.state -> 'e -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'e t ->
+ Ppx_hash_lib.Std.Hash.stateval has_check : 'a t -> boolMiddle.TypeA type which unifies SizedTypes and UnsizedTypes for declarations
val fold : ('a -> 'b -> 'a) -> 'c -> 'd t -> 'eval t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a tval sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.tval hash_fold_t :
+ 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state) ->
+ Ppx_hash_lib.Std.Hash.state ->
+ 'a t ->
+ Ppx_hash_lib.Std.Hash.stateval pp : 'a Fmt.t -> Stdlib.Format.formatter -> 'b t -> unitval to_unsized : 'a t -> UnsizedType.tUnsizedType.Comparatorval comparator : (t, comparator_witness) Core__Comparator.comparatorMap.Keytype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = Comparator.comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Keyval bin_size_t : Key.t Bin_prot__.Size.sizerval bin_write_t : Key.t Bin_prot__.Write.writerval bin_read_t : Key.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Key.t) Bin_prot__.Read.readerval bin_writer_t : Key.t Bin_prot__.Type_class.writerval bin_reader_t : Key.t Bin_prot__.Type_class.readerval bin_t : Key.t Bin_prot__.Type_class.tMap.Provide_bin_iomodule Key : sig ... endval bin_size_t : ('a, 'a t) Bin_prot__.Size.sizer1val bin_write_t : ('a, 'a t) Bin_prot__.Write.writer1val bin_read_t : ('a, 'a t) Bin_prot__.Read.reader1val __bin_read_t__ : ('a, int -> 'a t) Bin_prot__.Read.reader1val bin_writer_t : ('a, 'a t) Bin_prot__.Type_class.S1.writerval bin_reader_t : ('a, 'a t) Bin_prot__.Type_class.S1.readerval bin_t : ('a, 'a t) Bin_prot__.Type_class.S1.tProvide_hash.Keyval hash_fold_t : Base__.Hash.state -> Key.t -> Base__.Hash.stateMap.Provide_hashmodule Key : sig ... endval hash_fold_t :
+ 'a Base__Ppx_hash_lib.hash_fold ->
+ 'a t Base__Ppx_hash_lib.hash_foldProvide_of_sexp.Keyval t_of_sexp : Sexplib0.Sexp.t -> Key.tMap.Provide_of_sexpmodule Key : sig ... endval t_of_sexp : (Sexplib0.Sexp.t -> 'a__002_) -> Sexplib0.Sexp.t -> 'a__002_ tUnsizedType.Mapmodule Key : sig ... endtype !'a t = (Key.t, 'a, Key.comparator_witness) Core__Map_intf.Map.tval compare :
+ 'a Base__Ppx_compare_lib.compare ->
+ 'a t Base__Ppx_compare_lib.compareval equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equalval empty : ('k, 'cmp, 'a t) Core__Map_intf.Without_comparator.tval of_tree :
+ ('k, 'cmp, (Key.t, 'v, Key.comparator_witness) Core__Map_intf.Tree.t -> 'v t)
+ Core__Map_intf.Without_comparator.tval of_key_set :
+ (Key.t, Key.comparator_witness) Base.Set.t ->
+ f:(Key.t -> 'v) ->
+ 'v tmodule Provide_of_sexp (Key : sig ... end) : sig ... endmodule Provide_bin_io (Key : sig ... end) : sig ... endmodule Provide_hash (Key : sig ... end) : sig ... endval t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a tval sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.tUnsizedType.Replace_polymorphic_compareSet.Elttype t = tval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.ttype comparator_witness = Comparator.comparator_witnessval comparator : (t, comparator_witness) Core__Comparator.comparatorProvide_bin_io.Eltval bin_size_t : Elt.t Bin_prot__.Size.sizerval bin_write_t : Elt.t Bin_prot__.Write.writerval bin_read_t : Elt.t Bin_prot__.Read.readerval __bin_read_t__ : (int -> Elt.t) Bin_prot__.Read.readerval bin_writer_t : Elt.t Bin_prot__.Type_class.writerval bin_reader_t : Elt.t Bin_prot__.Type_class.readerval bin_t : Elt.t Bin_prot__.Type_class.tSet.Provide_bin_iomodule Elt : sig ... endval bin_size_t : t Bin_prot__.Size.sizerval bin_write_t : t Bin_prot__.Write.writerval bin_read_t : t Bin_prot__.Read.readerval __bin_read_t__ : (int -> t) Bin_prot__.Read.readerval bin_writer_t : t Bin_prot__.Type_class.writerval bin_reader_t : t Bin_prot__.Type_class.readerval bin_t : t Bin_prot__.Type_class.tProvide_hash.Eltval hash_fold_t : Base__.Hash.state -> Elt.t -> Base__.Hash.stateSet.Provide_hashmodule Elt : sig ... endval hash_fold_t : t Base__Ppx_hash_lib.hash_foldval hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_valueProvide_of_sexp.Eltval t_of_sexp : Sexplib0.Sexp.t -> Elt.tSet.Provide_of_sexpUnsizedType.Setmodule Elt : sig ... endtype t = (Elt.t, Elt.comparator_witness) Base.Set.tval compare : t Base__Ppx_compare_lib.compareval equal : t Base__Ppx_compare_lib.equalval empty : ('a, 'cmp, t) Core__Set_intf.Without_comparator.tval of_tree :
+ ('a, 'cmp, (Elt.t, Elt.comparator_witness) Core__Set_intf.Tree.t -> t)
+ Core__Set_intf.Without_comparator.tval of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Base.Map.t -> tmodule Provide_of_sexp (Elt : sig ... end) : sig ... endmodule Provide_bin_io (Elt : sig ... end) : sig ... endmodule Provide_hash (Elt : sig ... end) : sig ... endval t_of_sexp : Sexplib0__.Sexp.t -> tval sexp_of_t : t -> Sexplib0__.Sexp.tMiddle.UnsizedTypeTypes which have dimensionalities but not sizes, e.g. array[,,]
type t = | UInt| UReal| UVector| UComplex| URowVector| UMatrix| UComplexVector| UComplexRowVector| UComplexMatrix| UArray of t| UTuple of t list| UFun of argumentlist * returntype * bool Fun_kind.suffix * Mem_pattern.t| UMathLibraryFunctionand argumentlist = (autodifftype * t) listval compare_autodifftype : autodifftype -> autodifftype -> Core__.Import.intval compare_argumentlist : argumentlist -> argumentlist -> Core__.Import.intval compare_returntype : returntype -> returntype -> Core__.Import.intval hash_fold_t :
+ Ppx_hash_lib.Std.Hash.state ->
+ t ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_autodifftype :
+ Ppx_hash_lib.Std.Hash.state ->
+ autodifftype ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_argumentlist :
+ Ppx_hash_lib.Std.Hash.state ->
+ argumentlist ->
+ Ppx_hash_lib.Std.Hash.stateval hash_fold_returntype :
+ Ppx_hash_lib.Std.Hash.state ->
+ returntype ->
+ Ppx_hash_lib.Std.Hash.stateval hash : t -> Ppx_hash_lib.Std.Hash.hash_valueval hash_autodifftype : autodifftype -> Ppx_hash_lib.Std.Hash.hash_valueval hash_argumentlist : argumentlist -> Ppx_hash_lib.Std.Hash.hash_valueval hash_returntype : returntype -> Ppx_hash_lib.Std.Hash.hash_valueval t_of_sexp : Sexplib0.Sexp.t -> tval autodifftype_of_sexp : Sexplib0.Sexp.t -> autodifftypeval argumentlist_of_sexp : Sexplib0.Sexp.t -> argumentlistval returntype_of_sexp : Sexplib0.Sexp.t -> returntypeval sexp_of_t : t -> Sexplib0.Sexp.tval sexp_of_autodifftype : autodifftype -> Sexplib0.Sexp.tval sexp_of_argumentlist : argumentlist -> Sexplib0.Sexp.tval sexp_of_returntype : returntype -> Sexplib0.Sexp.tval equal_autodifftype : autodifftype -> autodifftype -> Core__.Import.boolval equal_argumentlist : argumentlist -> argumentlist -> boolval equal_returntype : returntype -> returntype -> boolval pp_tuple_autodifftype : autodifftype Fmt.tval returntype_to_type_opt : returntype -> t optionval pp_autodifftype : Stdlib.Format.formatter -> autodifftype -> unitval count_dims : t -> intval contains_tuple : t -> boolval pp : t Fmt.tval pp_fun_arg : (autodifftype * t) Fmt.tval pp_returntype : Stdlib.Format.formatter -> returntype -> unitval autodifftype_can_convert : autodifftype -> autodifftype -> boolval has_autodiff : autodifftype -> boolval any_autodiff : autodifftype list -> boolval lub_ad_type : autodifftype list -> autodifftype optionval is_autodiffable : t -> boolval is_autodifftype : autodifftype -> boolval is_dataonlytype : autodifftype -> boolval is_scalar_type : t -> boolval is_discrete_type : t -> boolUsed to determine valid covariates for _lpmf functions
val is_int_type : t -> boolUsed in code generation and other places, does _not_ include tuples of ints
val is_complex_type : t -> boolval is_eigen_type : t -> boolval is_fun_type : t -> boolval contains_int : t -> boolDetect if type contains an integer
val contains_eigen_type : t -> boolval is_container : t -> boolval is_array : t -> boolval is_indexing_matrix : (t * 'a list) -> boolval fill_adtype_for_type : autodifftype -> t -> autodifftypeIn some places (e.g. code generation) we need to instantiate an AD type. Previously we would just say DataOnly or AutoDiffable, however this breaks the invariant that a Tuple always has TupleAD as it's autodifftype
val enumerate_tuple_names_io : string -> t -> string listList all possible tuple sub-names for IO purposes. E.g, the decl array[2] (int, real) foo; should yield the list ["foo.1";"foo.2"].
module Comparator : sig ... endinclude module type of struct include Comparator endtype comparator_witness = Comparator.comparator_witnessinclude sig ... endval comparator : (t, Comparator.comparator_witness) Base__Comparator.comparatormodule Replace_polymorphic_compare : sig ... endmodule Map : sig ... endmodule Set : sig ... endMiddle.UtilsUtilities, primarily surrounding distribution names and suffixes
val tuple_trans_exn :
+ Expr.Typed.t Transformation.t ->
+ Expr.Typed.t Transformation.t listval zip_stuple_trans_exn :
+ 'a SizedType.t ->
+ 'b list ->
+ ('a SizedType.t * 'b) listval zip_utuple_trans_exn :
+ UnsizedType.t ->
+ 'a list ->
+ (UnsizedType.t * 'a) listMiddlemodule Expr : sig ... endMIR types and modules corresponding to the expressions of the language
module Flag_vars : sig ... endmodule Fun_kind : sig ... endTypes for function kinds, e.g. StanLib or UserDefined, and function suffix types, e.g. foo_ldfp, bar_lp
module Index : sig ... endTypes of indexing operations
module Internal_fun : sig ... endLanguage functions defined internally by the compiler
module Location : sig ... endStoring locations in the original source
module Location_span : sig ... endDelimited locations in source code
module Mem_pattern : sig ... endmodule Operator : sig ... endUtilities for Stan's built in operators
module Program : sig ... endDefines the core of the MIR
module SizedType : sig ... endTypes which have a concrete size associated, e.g. vector[n]
module Stan_math_signatures : sig ... endThis module stores a table of all signatures from the Stan math C++ library which are exposed to Stan, and some helper functions for dealing with those signatures.
module Stmt : sig ... endMIR types and modules corresponding to the statements of the language
module Transformation : sig ... endmodule Type : sig ... endA type which unifies SizedTypes and UnsizedTypes for declarations
module UnsizedType : sig ... endTypes which have dimensionalities but not sizes, e.g. array[,,]
module Utils : sig ... endUtilities, primarily surrounding distribution names and suffixes
Cpp.DeclsDeclarations which get re-used often in the generated model
val current_statement : stmt listval dummy_var : stmt listval serializer_in : stmtval serializer_out : stmtCpp.Expression_syntaxSome operators to make streams and method calls look more like the resultant C++
include module type of struct include Exprs endval method_call : expr -> identifier -> type_ list -> expr list -> exprCall a method on object, wrapping it in parentheses if it is not a variable
val to_var : identifier -> exprval literal_string : string -> exprTurn an OCaml string into a quoted and escaped C++ string
val fun_call : identifier -> expr list -> exprval templated_fun_call : identifier -> type_ list -> expr list -> exprval quiet_NaN : exprHelper for std::numeric_limits<double>::quiet_NaN()
val int_min : exprHelper for std::numeric_limits<int>::min()
val (.@!()) : expr -> identifier -> exprMethod call: Call a no-argument method
E.g. foo.bar()
val (.@?()) : expr -> (identifier * expr list) -> exprMethod call: Call the named method with args
E.g. foo.bar(A1,...An)
val (.@<>()) : expr -> (identifier * type_ list * expr list) -> exprMethod call: Call the named method with template types and args
E.g. foo.bar<T1,...,Tn>(A1,...An)
val (|::!) : type_ -> identifier -> exprStatic method call: Call the named method with no arguments.
E.g. Foo::bar()
val (|::?) : type_ -> (identifier * expr list) -> exprStatic method call: Call the named method with args
E.g. Foo::bar(A1,...An)
val (|::<>) : type_ -> (identifier * type_ list * expr list) -> exprStatic method call: Call the named method with template types and args
E.g. Foo::bar<T1,...,Tn>(A1,...An)
Cpp.ExprsSome helper values and functions
val method_call : expr -> identifier -> type_ list -> expr list -> exprCall a method on object, wrapping it in parentheses if it is not a variable
val to_var : identifier -> exprval literal_string : string -> exprTurn an OCaml string into a quoted and escaped C++ string
val fun_call : identifier -> expr list -> exprval templated_fun_call : identifier -> type_ list -> expr list -> exprval quiet_NaN : exprHelper for std::numeric_limits<double>::quiet_NaN()
val int_min : exprHelper for std::numeric_limits<int>::min()
Cpp.PrintingPretty-printing of the C++ type
val pp_type_ : type_ Fmt.tval pp_requires :
+ default:bool ->
+ Stdlib.Format.formatter ->
+ ([< `Exact of string | `OneOf of string list ] * type_) list ->
+ unitval pp_template :
+ default:bool ->
+ Stdlib.Format.formatter ->
+ template_parameter list ->
+ unitPretty print a list of templates as template <parameter-list>.name This function pools together RequireAllCondition nodes into a require_all_t
val pp_operator : Stdlib.Format.formatter -> operator -> unitval pp_expr : expr Fmt.tval pp_variable_defn : Stdlib.Format.formatter -> variable_defn -> unitval pp_stmt : stmt Fmt.tval pp_with_block :
+ ?indent:int ->
+ unit Fmt.t ->
+ Stdlib.Format.formatter ->
+ stmt ->
+ unitWhen we know a block is here, we can do better pretty-printing
val pp_cv : Stdlib.Format.formatter -> cv_qualifiers -> unitval pp_fun_defn : Stdlib.Format.formatter -> fun_defn -> unitval pp_destructor : Stdlib.Format.formatter -> (string * stmt list) -> unitval pp_constructor : Stdlib.Format.formatter -> (string * constructor) -> unitval pp_directive : Stdlib.Format.formatter -> directive -> unitval pp_class_defn : Stdlib.Format.formatter -> class_defn -> unitval pp_struct_defn : Stdlib.Format.formatter -> struct_defn -> unitval pp_defn : defn Fmt.tval pp_program : defn list Fmt.tCpp.StmtsHelpers for common statement constructs
Wrap the list of statements in a block if it isn't a singleton block already
Set up the try/catch logic for throwing an exception with its location set to the Stan program location.
val fori : identifier -> expr -> expr -> stmt -> stmtval unused : identifier -> stmt listSuppress warnings for a variable which may not be used.
Cpp.TestsCpp.TypesHelpers for constructing types
val local_scalar : type_val bool : type_val vector : ?mem_pattern:Middle.Mem_pattern.t -> type_ -> type_An Eigen::Matrix<s, -1, 1>
val row_vector : ?mem_pattern:Middle.Mem_pattern.t -> type_ -> type_An Eigen::Matrix<s, 1, -1>
val matrix : ?mem_pattern:Middle.Mem_pattern.t -> type_ -> type_An Eigen::Matrix<s, -1, -1>
val string : type_A std::string
val size_t : type_val const_char_array : int -> type_Stan_math_backend.CppA set of data types representing the C++ we generate
val identifier_of_sexp : Sexplib0.Sexp.t -> identifierval sexp_of_identifier : identifier -> Sexplib0.Sexp.ttype type_ = | Auto| Void| Int| Double| Complex of type_| TemplateType of identifier| StdVector of type_A std::vector. For Eigen Vectors, use Matrix with a row or column size of 1
| Array of type_ * int| Tuple of type_ list| TypeLiteral of identifierUsed for things like Eigen::Index
*)| Matrix of type_ * int * int * Middle.Mem_pattern.t| Ref of type_| Const of type_| Pointer of type_| TypeTrait of identifier * type_ liste.g. stan::promote_scalar, stan:base_type
*)C++ types
val type__of_sexp : Sexplib0.Sexp.t -> type_val sexp_of_type_ : type_ -> Sexplib0.Sexp.tmodule Types : sig ... endHelpers for constructing types
val operator_of_sexp : Sexplib0.Sexp.t -> operatorval sexp_of_operator : operator -> Sexplib0.Sexp.ttype expr = | Literal of stringprinted as-is
*)| Var of identifier| VarRef of identifier| Parens of expr| FunCall of identifier * type_ list * expr list| MethodCall of expr * identifier * type_ list * expr list| StaticMethodCall of type_ * identifier * type_ list * expr list| Constructor of type_ * expr listprinted as type(expr1, expr2, ...)
| InitializerExpr of type_ * expr listprinted as type{expr1, expr2, ...}
| ArrayLiteral of expr list| TernaryIf of expr * expr * expr| Cast of type_ * expr| Index of expr * expr| Deref of expr| AllocNew of type_ * expr list| OperatorNew of identifier * type_ * expr list| Assign of expr * exprNB: Not all exprs are valid lvalues!
*)| StreamInsertion of expr * expr listCorresponds to operator<<
| BinOp of expr * operator * expr| PMinus of expr| Increment of exprval expr_of_sexp : Sexplib0.Sexp.t -> exprval sexp_of_expr : expr -> Sexplib0.Sexp.tmodule Exprs : sig ... endSome helper values and functions
module Expression_syntax : sig ... endSome operators to make streams and method calls look more like the resultant C++
val init_of_sexp : Sexplib0.Sexp.t -> initval sexp_of_init : init -> Sexplib0.Sexp.tval make_variable_defn :
+ ?static:bool ->
+ ?constexpr:bool ->
+ type_:type_ ->
+ name:identifier ->
+ ?init:init ->
+ unit ->
+ variable_defnval variable_defn_of_sexp : Sexplib0.Sexp.t -> variable_defnval sexp_of_variable_defn : variable_defn -> Sexplib0.Sexp.ttype stmt = | Expression of expr| VariableDefn of variable_defn| For of variable_defn * expr * expr * stmt| ForEach of type_ * identifier * expr * stmt| While of expr * stmt| IfElse of expr * stmt * stmt option| TryCatch of stmt list * type_ * identifier * stmt list| Block of stmt list| Return of expr option| Throw of expr| Break| Continue| Using of string * type_ option| Comment of stringval stmt_of_sexp : Sexplib0.Sexp.t -> stmtval sexp_of_stmt : stmt -> Sexplib0.Sexp.tmodule Stmts : sig ... endHelpers for common statement constructs
module Decls : sig ... endDeclarations which get re-used often in the generated model
type template_parameter = | Typename of stringThe name of a template typename
*)| RequireAllCondition of [ `Exact of string | `OneOf of string list ] * type_A C++ type trait (e.g. is_arithmetic) and the template name which needs to satisfy that. These are collated into one require_all_t<>
*)| Require of string * string list| Bool of stringA named boolean template type
*)val template_parameter_of_sexp : Sexplib0.Sexp.t -> template_parameterval sexp_of_template_parameter : template_parameter -> Sexplib0.Sexp.tval cv_qualifiers_of_sexp : Sexplib0.Sexp.t -> cv_qualifiersval sexp_of_cv_qualifiers : cv_qualifiers -> Sexplib0.Sexp.ttype fun_defn = {templates_init : template_parameter list list * bool;Double list since some functions (mainly reduce_sum functors) need two sets of templates
*)inline : bool;return_type : type_;name : identifier;args : (type_ * string) list;cv_qualifiers : cv_qualifiers list;body : stmt list option;}val make_fun_defn :
+ ?templates_init:(template_parameter list list * bool) ->
+ ?inline:bool ->
+ return_type:type_ ->
+ name:identifier ->
+ ?args:(type_ * string) list ->
+ ?cv_qualifiers:cv_qualifiers list ->
+ ?body:stmt list ->
+ unit ->
+ fun_defnval fun_defn_of_sexp : Sexplib0.Sexp.t -> fun_defnval sexp_of_fun_defn : fun_defn -> Sexplib0.Sexp.ttype constructor = {args : (type_ * string) list;init_list : (identifier * expr list) list;body : stmt list;}val make_constructor :
+ ?args:(type_ * string) list ->
+ ?init_list:(identifier * expr list) list ->
+ ?body:stmt list ->
+ unit ->
+ constructorval constructor_of_sexp : Sexplib0.Sexp.t -> constructorval sexp_of_constructor : constructor -> Sexplib0.Sexp.ttype directive = | Include of string| IfNDef of string * defn list| MacroApply of string * string listIncomplete list of C++ preprocessor directives
and class_defn = {class_name : identifier;final : bool;public_base : type_;private_members : defn list;public_members : defn list;constructor : constructor;destructor_body : stmt list;}The Stan model class always has a non-default constructor and destructor
and defn = | FunDef of fun_defn| Class of class_defn| Struct of struct_defn| GlobalVariableDefn of variable_defn| GlobalComment of string| GlobalUsing of string * type_ option| Namespace of identifier * defn list| Preprocessor of directiveval directive_of_sexp : Sexplib0.Sexp.t -> directiveval class_defn_of_sexp : Sexplib0.Sexp.t -> class_defnval struct_defn_of_sexp : Sexplib0.Sexp.t -> struct_defnval defn_of_sexp : Sexplib0.Sexp.t -> defnval sexp_of_directive : directive -> Sexplib0.Sexp.tval sexp_of_class_defn : class_defn -> Sexplib0.Sexp.tval sexp_of_struct_defn : struct_defn -> Sexplib0.Sexp.tval sexp_of_defn : defn -> Sexplib0.Sexp.tval make_class_defn :
+ name:identifier ->
+ public_base:type_ ->
+ ?final:bool ->
+ private_members:defn list ->
+ public_members:defn list ->
+ constructor:constructor ->
+ ?destructor_body:stmt list ->
+ unit ->
+ class_defnval make_struct_defn :
+ param:template_parameter option ->
+ name:identifier ->
+ body:defn list ->
+ unit ->
+ struct_defntype program = defn listMuch like in C++, we define a translation unit as a list of definitions
val program_of_sexp : Sexplib0.Sexp.t -> programval sexp_of_program : program -> Sexplib0.Sexp.tmodule Printing : sig ... endPretty-printing of the C++ type
module Tests : sig ... endStan_math_backend.Cpp_Jsonval out_var_interpolated_json_str :
+ (string * Middle.Expr.Typed.t Middle.SizedType.t * Middle.Program.io_block)
+ list ->
+ stringStan_math_backend.Cpp_strUtilities for converting OCaml strings into C++ strings
Lower_expr.Testingval dummy_locate :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Expr.Fixed.Pattern.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.tval pp_unlocated :
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Expr.Fixed.Pattern.t ->
+ stringStan_math_backend.Lower_exprLowering of Stan expressions to C++
val constraint_to_string : 'a Middle.Transformation.t -> string optionval hash_fold_variadic :
+ Ppx_hash_lib.Std.Hash.state ->
+ variadic ->
+ Ppx_hash_lib.Std.Hash.stateval hash_variadic : variadic -> Ppx_hash_lib.Std.Hash.hash_valueval functor_type : string Core.Hashtbl.key -> variadicval functor_suffix_select : variadic -> stringval is_scalar : Middle.Expr.Typed.t -> boolval is_matrix : Middle.Expr.Typed.t -> boolUsed to determine if operator/ should be mdivide_right() or divide()
val is_row_vector : Middle.Expr.Typed.t -> boolval transform_args :
+ Middle__Expr.Typed.Meta.t Middle__Expr.Fixed.t Middle.Transformation.t ->
+ Middle__Expr.Typed.Meta.t Middle__Expr.Fixed.t Base__List.tval is_single_index : 'a Middle.Index.t -> boolval dont_need_range_check : 'a Middle.Expr.Fixed.t Middle.Index.t -> boolval promote_adtype :
+ Middle.Expr.Typed.t list ->
+ Middle.UnsizedType.autodifftypeval suffix_args : 'a Middle.Fun_kind.suffix -> string listval stantype_prim : Middle.UnsizedType.t -> Cpp.type_val templates : bool -> bool Middle.Fun_kind.suffix -> Cpp.type_ listval deserializer : Cpp.exprval local_scalar :
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Cpp.type_val minus_one : Stan_math_backend__Cpp.expr -> Cpp.exprval plus_one : Stan_math_backend__Cpp.expr -> Cpp.exprval lower_type :
+ ?mem_pattern:Middle.Mem_pattern.t ->
+ Middle.UnsizedType.t ->
+ Cpp.type_ ->
+ Cpp.type_val lower_unsizedtype_local :
+ ?mem_pattern:Middle.Mem_pattern.t ->
+ Middle.UnsizedType.autodifftype ->
+ Middle.UnsizedType.t ->
+ Cpp.type_val lower_possibly_var_decl :
+ Middle.UnsizedType.autodifftype ->
+ Middle.UnsizedType.t ->
+ Middle.Mem_pattern.t ->
+ Cpp.type_val lower_logical_op :
+ Cpp.operator ->
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.t ->
+ Cpp.exprval lower_binary_fun :
+ string ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval vector_literal :
+ ?column:bool ->
+ Cpp.type_ ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval read_data :
+ Middle.UnsizedType.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval lower_binary_op :
+ Cpp.operator ->
+ string ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval lower_operator_app :
+ Middle.Operator.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval lower_misc_special_math_app :
+ Core.String.Map.Key.t ->
+ Middle.Mem_pattern.t ->
+ Middle.UnsizedType.returntype option ->
+ (Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.expr)
+ optionval lower_functionals :
+ string Core.Hashtbl.key Core.Hashtbl.key ->
+ bool Middle.Fun_kind.suffix ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Middle.Mem_pattern.t ->
+ (Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.expr)
+ optionval lower_fun_app :
+ bool Middle.Fun_kind.suffix ->
+ Core.String.Map.Key.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Middle.Mem_pattern.t ->
+ Middle.UnsizedType.returntype option ->
+ Cpp.exprval lower_user_defined_fun :
+ string ->
+ bool Middle.Fun_kind.suffix ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval lower_compiler_internal :
+ Middle.UnsizedType.autodifftype ->
+ Middle.UnsizedType.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Middle.Internal_fun.t ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.exprval lower_index : Middle.Expr.Typed.t Middle.Index.t -> Cpp.exprval lower_indexed :
+ Middle.Expr.Typed.t ->
+ Middle.Expr.Typed.t Middle.Index.t list ->
+ string ->
+ Cpp.exprval lower_indexed_simple :
+ Cpp.expr ->
+ Middle.Expr.Typed.t Middle.Index.t Core__.Import.list ->
+ Cpp.exprval lower_expr : ?promote_reals:bool -> Middle.Expr.Typed.t -> Cpp.exprval lower_exprs :
+ ?promote_reals:bool ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t Base__List.t ->
+ Cpp.expr Base__List.tmodule Testing : sig ... endStan_math_backend.Lower_functionsResponsible for turning the Stan function's block into forward decls, functions, and functors in C++
val collect_functors_functions : Middle.Program.Numbered.t -> Cpp.defn listval lower_standalone_fun_def :
+ string ->
+ 'a Middle.Program.fun_def ->
+ Cpp.defn listStan_math_backend.Lower_programStan-program-specific C++ generation
val lower_program :
+ ?printed_filename:string ->
+ Middle.Program.Typed.t ->
+ Cpp.programLower_stmt.TestingStan_math_backend.Lower_stmtLowering of Stan statements to C++
val lower_st :
+ 'a Middle.SizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Cpp.type_val check_to_string : 'a Middle.Transformation.t -> string optionval math_fn_translations : 'a Middle.Internal_fun.t -> string optionval trans_math_fn : 'a Middle.Internal_fun.t -> stringval initialize_value :
+ Middle.Expr.Typed.t Middle.SizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Cpp.exprval lower_assign_sized :
+ Middle.Expr.Typed.t Middle.SizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Middle.Expr.Typed.t Middle.Stmt.Fixed.Pattern.decl_init ->
+ Cpp.expr optionval lower_unsized_decl :
+ Cpp.identifier ->
+ Middle.UnsizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Cpp.variable_defnval lower_possibly_opencl_decl :
+ string ->
+ 'a Middle.SizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ 'b Middle.Expr.Fixed.t Middle.Stmt.Fixed.Pattern.decl_init ->
+ Cpp.type_val lower_sized_decl :
+ Cpp.identifier ->
+ Middle.Expr.Typed.t Middle.SizedType.t ->
+ Middle.UnsizedType.autodifftype ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t
+ Middle.Stmt.Fixed.Pattern.decl_init ->
+ Cpp.variable_defnval lower_decl :
+ Cpp.identifier ->
+ Middle.Expr.Typed.t Middle.Type.t ->
+ Middle.UnsizedType.autodifftype ->
+ Middle.Expr.Typed.Meta.t Middle.Expr.Fixed.t
+ Middle.Stmt.Fixed.Pattern.decl_init ->
+ Cpp.stmtval lower_profile :
+ Cpp.identifier ->
+ Cpp.stmt list ->
+ Stan_math_backend__Cpp.stmtval lower_bool_expr : Middle.Expr.Typed.t -> Cpp.exprval lower_nonrange_lvalue :
+ Middle.Expr.Typed.t Middle.Stmt.Fixed.Pattern.lvalue ->
+ Cpp.exprval lower_nonrange_lbase :
+ Middle.Expr.Typed.t Middle.Stmt.Fixed.Pattern.lbase ->
+ Cpp.exprval expr_overlaps_lhs_ref :
+ 'a Middle.Expr.Fixed.t Middle.Stmt.Fixed.Pattern.lvalue ->
+ 'a0 Middle.Expr.Fixed.t ->
+ boolval throw_exn :
+ string ->
+ Middle.Expr.Typed.t list ->
+ Stan_math_backend__Cpp.stmtval lower_statement :
+ (Middle.Expr.Typed.Meta.t, Middle.Stmt.Numbered.Meta.t) Middle.Stmt.Fixed.t ->
+ Cpp.stmt listval lower_statements :
+ (Middle.Expr.Typed.Meta.t, Middle.Stmt.Numbered.Meta.t) Middle.Stmt.Fixed.t
+ list ->
+ Cpp.stmt Base__List.tmodule Testing : sig ... endStan_math_backend.MangleMangle variables which are C++ reserved words into valid C++ identifiers.
This is done in Transform_Mir. When one of these names is emitted as a string, we use remove_prefix such that this mangling is opaque to the user - e.g., a cmdstan output file would still have a column called "public", even if internally we called this "_stan_public"
NB: the use of a leading _ is essential, because the lexer won't allow this in a user-created variable.
Used in code generation so that this mangling is opaque to the interfaces (e.g. cmdstan)
Stan_math_backend.NumberingThis module translates the locations of statements into an array of messages used in the C++ for providing locations in the Stan code when an error occurs, and replaces the locations in the MIR tree with indices into said array.
It also numbers calls to map_rect for registration.
val prepare_prog :
+ Middle.Program.Typed.t ->
+ Middle.Program.Numbered.t * state_t * map_rect_registration_tval no_span_num : Middle.Stmt.Numbered.Meta.tval assign_loc : Middle.Stmt.Numbered.Meta.t -> Cpp.stmt listval register_map_rect_functors :
+ string ->
+ map_rect_registration_t ->
+ Cpp.defn listRegister functiors used for map_rect.
Stan_math_backend.Transform_MirPerform backend-specific transformations of the MIR such as mangling or renaming of functions which differ in the library implementation
val trans_prog : Middle.Program.Typed.t -> Middle.Program.Typed.tStan_math_backendmodule Cpp : sig ... endA set of data types representing the C++ we generate
module Cpp_Json : sig ... endmodule Cpp_str : sig ... endUtilities for converting OCaml strings into C++ strings
module Lower_expr : sig ... endLowering of Stan expressions to C++
module Lower_functions : sig ... endResponsible for turning the Stan function's block into forward decls, functions, and functors in C++
module Lower_program : sig ... endStan-program-specific C++ generation
module Lower_stmt : sig ... endLowering of Stan statements to C++
module Mangle : sig ... endMangle variables which are C++ reserved words into valid C++ identifiers.
module Numbering : sig ... endThis module translates the locations of statements into an array of messages used in the C++ for providing locations in the Stan code when an error occurs, and replaces the locations in the MIR tree with indices into said array.
module Transform_Mir : sig ... endPerform backend-specific transformations of the MIR such as mangling or renaming of functions which differ in the library implementation
This is not meant to be tutorial on the OCaml language itself, but rather on some of the features and libraries of Stanc3 which may not be familiar to developers who do have some OCaml exposure.
We use Jane Street's Core standard library. There are a few differences from the OCaml standard library which are instantly noticeable:
Most higher-order functions such as List.map take a named function argument.
This means a call like List.map square [1;2;3] will look like List.map ~f:square [1;2;3].
Core defaults to safe operations which return options rather than possibly erring.
In "normal" OCaml, List.hd has type 'a list -> 'a. A call List.hd [] will throw an exception. By contrast, in the Jane Street libraries, the same function has type 'a list -> 'a option.
Usually, a function with the suffix _exn recovers the original signature, e.g. List.hd_exn : 'a list -> 'a .
If for some reason you need functionality from the OCaml standard library that is not available in Jane Street (be sure to triple check), you can use the modules Stdlib and Caml to access the built-in versions. Currently there is only one such usage in the compiler, to use the standard definition of != in the Menhir parser.
There are a few other things we gain from these libraries. The most important idea to understand is deriving.
If you look at a type declaration of something like Ast.typed_expression, you'll notice something curious after the declaration:
type typed_expression = (typed_expr_meta, fun_kind) expr_with
+[@@deriving sexp, compare, map, hash, fold]When using an editor that supports code completion, you may notice that the Ast module suggests functions which are not defined in the actual source text. This is because these functions are created at compile time by ppx_deriving.The above syntax [@@deriving ...] indicates which functions we would like to be generated.
These are very helpful - if a type derives hash, it can automatically be used as keys in Jane Street's hash tables, and a type which derives sexp can be serialized to Lisp-style S-Expressions. Most of our major types derive at least one function.
The other curious thing about the types we define in our AST and MIR is that they use a trick known as "two level types". This allows re-using the same type structure with different amounts of metadata attached (e.g., before type checking we have an untyped_program which only has nodes and their source locations, after type checking we have typed_program which features nodes, locations, and types, in the same basic tree structure.
The way that this is implemented is a bit non-obvious at first. Essentially, many of the tree variant types are parameterized by something that ends up being a placeholder not for just metadata but for the recursive type including metadata, sometimes called the fixed point. 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.
This takes some getting used to, and also can lead to some unhelpful type signatures in editors such as VSCode, because abbreviations are not always used in hover-over text. For example, Expr.Typed.t, the MIR's typed expression type, actually has a signature of Expr.Typed.Meta.t Expr.Fixed.t.
Fmt library and pretty-printingWe extensively use the Fmt library for our pretty-printing and code generation. We have an existing guide on the wiki which covers the core ideas.
The main backend of the compiler is the "Stan Math" (C++) backend. We represent C++ code with a data types and functions found in Stan_math_backend.Cpp.
We also define a sort of miniature embedded domain specific language (DSL) for using these types. These helper functions and operators are all in sub-modules of Stan_math_backend.Cpp, for example Stan_math_backend.Cpp.Expression_syntax.
These allow writing OCaml code which looks or feels more like the C++ it will generate. These constructs should be used when they improve clarity, and avoided when they make the code harder to read. When combined with good variable names, this can lead to code like lp_accum__.@?(("add", [Var "lp__"])) , which hopefully reads quite clearly as equivalent to the C++ lp_accum__.add(lp__).
After a Stan program is lowered to this type, it can be printed to C++ using Stan_math_backend.Cpp.Printing. This module uses Fmt, but keeps the question of how C++ should be formatted separate from the question of what the generated C++ is.
For example, lets say one wanted to generate the expression
(Eigen::Matrix<double,1,-1>(3) << 1, a, 3).finished()This could be written down as the literal OCaml type it is:
(MethodCall (Parens (StreamInsertion (Constructor (Matrix (Double, 1, -1), [Literal "3"]), [Literal "1"; Var "a"; Literal "3"]), "finished", [], [])Or, using the DSL constructs, the same expression could be written
let open Expression_syntax in
+let open Types in
+let vector = Constructor (row_vector Double, [Literal "3"]) in
+let values = [Literal "1"; Var "a"; Literal "3"] in
+(vector << values).@!("finished")We rely on the following packages. Note that because of the requirements for Cross Compilation for Windows, these versions are exactly pinned.
These are automatically installed through the scripts/install_ocaml.sh and scripts/install_build_deps.sh scripts provided in the stanc3 repository.
For the JavaScript interface to stanc3 we also use the following, installed via scripts/install_js_deps.sh
The stancjs executable can be built with
dune build src/stancjs
There are several packages which are useful for development but not required for building stanc3. These can be installed with scripts/install_dev_deps.sh, or (alongside the above build requirements) with scripts/setup_dev_env.sh. Versioning of these dependencies is less strict, though some (like ocamlformat) are used to ensure a standard format across developers and must use the same version.
To support Windows binaries, we use versions of OCaml and all our dependencies which are available on opam-cross-windows. This allows us to build Windows-compatible versions on non-Windows machines.
For more information on cross-compilation, see the dune docs.
To build Windows binaries, the above build requirements must have their opam-cross-windows equivalents installed. This can be done by executing scripts/install_build_deps_windows.sh.
Then, the command
dune build -x windows
will build a Windows binary.
For a function to be built into Stan, it has to be included in the Stan Math library and its signature has to be exposed to the compiler.
To do the latter, we have to add a corresponding line in src/middle/Stan_math_signatures.ml. The compiler uses the signatures defined there to do type checking.
To add a distribution, we have to find the line containing let distributions =. The existing distributions can be used for reference. The first argument defines the kind of function we want to add. The second argument is the base function name without the _... suffixes. The third argument specifies the argument types of the function. The last argument describes the memory pattern supported by this function, either an Array of Structs (AoS) or a Struct of Arrays (SoA). The following line exposes a function foo_lpdf which takes in a (non-vectorizable) real number and a (non-vectorizable) integer :
; ([Lpdf], "foo", [DReal; DInt], SoA)To see the exact signatures created, we can recompile stanc using make all and display the signatures using stanc --dump-stan-math-signatures. By filtering for foo (for example by using grep), we get the following output:
$ stanc --dump-stan-math-signatures | grep foo
+foo_lpdf(real, int) => realIf we want to allow the first parameter to be vectorizable, we can change the signature to
; ([Lpdf], "foo", [DVReal; DReal], SoA)This produces the following signatures:
$ stanc --dump-stan-math-signatures | grep foo
+foo_lpdf(real, int) => real
+foo_lpdf(vector, int) => real
+foo_lpdf(row_vector, int) => real
+foo_lpdf(array[] real, int) => realAs we can see, allowing a parameter to be vectorized automatically produces signatures where the parameter is either base type, vector, row_vector or array[].
The following parameter types are available:
DInt: Scalar integer -> intDReal: Scalar real number -> realDVector: Vector -> vectorDMatrix: Matrix -> matrixDIntArray: Integer array -> array[] intDVInt: Vectorizable integer -> int; array[] intDVReal: Vectorizable real number -> real; vector; row_vector; array[] realDVectors: Vectorizable vectors (for multivariate functions) -> vector, row_vector, array[] vector, array[] row_vectorDDeepVectorized: all base types with up to 8 levels of nested containers)As we have seen above, specifying our function as [Lpdf] added the suffix _lpdf to our base function name. There are several types available which specify the suffixes that will be added:
Lpmf: _lpmfLpdf: _lpdfRng: _rngCdf: _cdf, _lcdfCcdf: _lccdfAdditionally, full_lpdf combines all suffixes of Lpdf, Rng, Ccdf and Cdf. full_lpmf does the same, but using the suffixes of Lpmf instead of Lpdf. Note that these two have to be used without brackets. This means we would write
; ([Cdf], "foo", [DReal; DInt], SoA)but
; (full_lpdf, "foo", [DReal; DInt], SoA)which corresponds to
; ([Lpdf; Rng; Ccdf; Cdf], "foo", [DReal; DInt], SoA)Standard functions (e.g., not distributions or variadic functions) are added to a list in the same file. This list begins near the bottom of the file with the line
(* -- Start populating stan_math_signaturess -- *)
+let () =The statements in this list use several helper functions, such as add_unqualified, add_qualified, add_binary, etc.
The core function of these is add_qualified, which registers a function based on:
UnsizedType.returntype)UnsizedType.autodifftype * UnsizedType.t tuples)All other functions are simply helpers for calling this one. For example, if a function does not have any arguments it requires to be of type data, then add_unqualified is provided for convience. It does the same thing as add_qualfied, but the third argument is just a list of UnsizedType.ts. Other helpers, such as add_binary, exist for common cases such as a function with a signature (real, real) => real
If a function has multiple signatures, it will generally need multiple calls to these functions. Some helpers, such as add_binary_vec add multiple signatures at once for vectorized functions.
For example, the following line defines the signature add(real, matrix) => matrix
add_unqualified ("add", ReturnType UMatrix, [UReal; UMatrix], SoA) ;Functions such as the ODE integrators or reduce_sum, which take in user-functions and a variable-length list of arguments, are NOT added to this list.
"Nice" variadic functions are added to the hashtable Stan_math_signatures.stan_math_variadic_signatures. This is probably sufficient for most variadic functions, e.g. all the ODE solvers and DAE solvers are done via this method. reduce_sum is not "nice", since it is both variadic and polymorphic, requiring certain arguments to have the same (but not predetermined) type. Therefore, reduce_sum is treated as special case in the Typechecker module in the frontend folder.
Note that higher-order functions also usually require changes to the C++ code generation to work properly. It is best to consult an existing example of how these are done before proceeding.
Functions exposed from the Stan Math Library are tested for all declared signatures. These tests live in the folder test/integration/good/function-signatures. They consist of a basic Stan program (or multiple programs for functions with a large number of overloads) which call the new function on each possible combination of arguments.
These tests confirm both that the typechecker accepts these signatures and that the C++ generated for them compiles against the Math Library implementations.
Finally, before a function can be exposed in the Stan compiler it needs to be added to the Stan Functions Reference, which is stored at stan-dev/docs. New PRs to stanc3 will prompt you to link to the accompanying documentation PR.
The recommended way to develop stanc3 is using opam and dune on a Unix-like system (MacOS or Linux). See Windows development for tips on developing on Windows.
This requires you have make, git, curl, and m4 installed via apt, homebrew, or your system's package manager.
Install the necessary dependencies by running
cd scripts; bash -x ./setup_dev_env.sh.
If you already have opam installed, you can instead run
opam update; opam install --deps-only --with-test .
If you wish to install stanc on your system, you can run the above opam command without --deps-only.
make. If this succeeds, you have the required software.We recommend using Windows Subsystem for Linux (WSL) for development on Windows. While this will not produce native-Windows binaries by default (though they can be cross-compiled), it is far easier to use and set up than the other options for Windows development.
Once you have installed and configured WSL, you can proceed through the steps above through the WSL shell.
Nix is a declarative package manager with a focus on reproducible builds. We provide the ability to use Nix to build, test and run Stanc3. We recommend trying the opam instructions first if you are not an existing Nix user, with these as a backup.
If you have nix installed, you can build Stanc3 by running the following command in the stanc3 directory:
nix-build
The binary will be in result/bin/stanc. It may take a minute the first time you run it. Alternatively, the following is sometimes a faster way to build:
nix-shell --command "dune build"
To run the test suite, run:
nix-shell --command "dune build --profile release @runtest"
To install Stanc3 to your system, run:
nix-env -i -f default.nix
To drop into a sandboxed development shell with all of the build dependencies of Stanc3 plus packages for an OCaml development environment (dune, ocp-indent, ocamlformat, merlin and utop), run:
nix-shell
Once you have the necessary software, you can make your edits to the source files in src/ and tests in test/. Running the command dune runtest (or make test) will show any test output which is different from the expected output. In our continuous integration, this results in test failures. If you are knowingly changing the output, and the differences highlighted by dune runtest look correct, you can run dune promote to change the expected output to match your current tests.
We have support for computing test coverage using the bisect_ppx library. To generate a coverage report, run make testcoverage. This will print a summary of the coverage to the terminal, and generate a detailed HTML report in the _coverage directory. This report can be opened in a web browser.
Code coverage of the master branch is available on codecov.io.
We recommend setting up your editor to use OCamlformat automatically. This will differ by editor, but is possible in most popular editors such as Emacs, VSCode, etc. See Editor advice for more specific tips.
If you would like to manually run the auto-formatter on all OCaml code in the repository, run make format. Similar to the above, you will need to run dune promote to accept these changes into the code.
If you would like to run the formatter before each commit (recommended), run
scripts/hooks/install_hooks.sh
Note: ocamlformat does not support .mly or .mll files used in the frontend.
If the parser has been edited, the command dune build @update_messages will add any new error states to the parser.messages file. These will say
TODO: PARSER MESSAGE NEEDED HERE.
See adding or changing the syntax error messages for more information.
Note that python3 is required to run this command.
Docs can be built with make doc. This will generate a _build/default/_doc/_html/index.html file which can be opened in a web browser.
In order to use the locally built development version of stanc3 with CmdStan, you need to set the STANC3 makefile variable in the make/local file in CmdStan. Example:
STANC3=relative/or/absolute/path/to/the/cloned/stanc3/folder
This will automatically rebuild the stanc3 binary used in CmdStan if a change was made to the stanc3 source files.
For working on this project, we recommend using either VSCode or Emacs as an editor, due to their good OCaml support through Merlin: syntax highlighting, auto-completion, type inference, automatic case splitting, and more. For people who prefer a GUI and have not memorized all Emacs or Vim keystrokes, VSCode might have the less steep learning curve. Anything with Merlin support is fine.
Install instructions for VSCode can be found here.
For Windows users: We recommend using Remote - WSL to program within WSL from a native Windows installation of VSCode. This extension allows you to connect to the WSL instance as if it is a remote machine, removing the need for an X11 server or other method of running a Linux GUI app directly.
Once in VSCode (on any platform), simply install the OCaml extension and you should be ready to go.
The best way to edit OCaml in Emacs is through Tuareg mode.
To get full Merlin support, you will need to run opam user-setup install after installing Merlin in our dev dependencies.
If you use use-package.el, this snippet should set up Tuareg+Merlin+OCamlformat
(use-package tuareg
+ :config
+ (electric-indent-mode 0)
+ (face-spec-set
+ 'tuareg-font-lock-constructor-face
+ '((((class color) (background light)) (:foreground "SaddleBrown"))
+ (((class color) (background dark)) (:foreground "burlywood1"))))
+ (add-hook 'tuareg-mode-hook
+ (lambda ()
+ (prettify-symbols-mode 0))))
+(use-package merlin
+ :config
+ (add-hook 'tuareg-mode-hook 'merlin-mode t)
+ (with-eval-after-load 'company
+ (add-to-list 'company-backends 'merlin-company-backend)))
+
+(require 'ocamlformat)
+(add-hook 'tuareg-mode-hook
+ (lambda ()
+ (define-key tuareg-mode-map (kbd "C-M-<tab>") #'ocamlformat)
+ (add-hook 'before-save-hook #'ocamlformat-before-save)))Even to an experienced OCaml developer, there are certain practices in the stanc3 codebase which might be unfamiliar. We have tried to document those on our Core ideas page.
OCaml has support for building binaries instrumented for use with theAFL++ fuzzing tool. This requires a new opam switch which includes the ocaml-option-afl base package.
opam switch create "stanc-fuzz" --packages "ocaml-option-afl,ocaml.4.14.1"
+eval $(opam env)
+./scripts/install_build_deps.shAfter this, the normal build process will produce a binary ready for fuzzing.
Profiling support is not directly provided in the stanc3 repository, but you can use the Landmarks library to profile the code.
This requires editing the dune files in the src/ directory to include the landmarks library, similar to how the bisect_ppx library is instrumented by default.
(instrumentation
+ (backend landmarks --auto))You can then build a profiled version of the code by running dune build src/stanc/stanc.exe --instrument-with landmarks --force.
To configure the profiler at runtime, consult the Landmarks documentation. A good starting command is
OCAML_LANDMARKS="on,output=prof.txt" stanc.exe mymodel.stanThis document provides the documentation for the internals of the stanc3 compiler intended for developers.
If you are looking for the user-facing documentation, see this section of the Stan User's Guide.
See the Getting Started page for information on setting up a stanc3 development environment.
Here are some resources (internal and external) which may be useful to a new developer.
The major code sections of the compiler are as follows (these are links):
These are related in the following architecture diagram
We additionally use several outside dependencies.
Stanc3 uses Menhir's Incremental API to provide custom error messages for when the parser detects an error. Menhir and the Incremental API are documented in the reference manual. We write the custom error messages in src/frontend/parser.messages file, which follows Menhir's messages format (documented here. Those messages are automatically integrated into the parser by the build rules defined in src/frontend/dune.
This process is less obvious than it seems and has some important to understand caveats. Please read the above section of the Menhir manual before making changes to the parser or syntax errors.
Each rule in parser.messages indicates the error state it corresponds to by specifying any stack of tokens which result in that error state.
There may be many such stacks of tokens which could correspond to the same error. Menhir will point out if there are two rules defined for the same error, but it will only show you one of them.
Find the existing error message for the parser error in question by either:
Suppose I want to change the error message for when the program is missing a { after the model keyword.
I write an example Stan program that has the error:
parameters {
+ real x;
+}
+model
+ x ~ normal(0, 1);
+}Now I compile this program with stanc3 using the --debug-parse option. The result:
...
+Expected "{" after "model".
+(Parse error state 685)The parse error state I'm looking for is 685. I search the parser.messages file for "685" (perhaps with the command `grep -n 685 src/frontend/parser.messages`), and I find:
program: MODELBLOCK WHILE
+##
+## Ends in an error in state: 685.
+##
+## model_block -> MODELBLOCK . LBRACE list(vardecl_or_statement) RBRACE [ GENERATEDQUANTITIESBLOCK EOF ]
+##
+## The known suffix of the stack is as follows:
+## MODELBLOCK
+##
+
+Expected "{" after "model".I can now replace this message with my new version
Often a new language feature will need new syntax messages. The command dune build @update_messages will add dummy error messages to parser.messages that you can replace. This sub-command requires Python 3 to be installed.
It is crucial to understand that the example programs Menhir provides in this file may not represent all possible programs leading to this state. See this section of the Menhir manual for specific advice.
Sometimes it is desirable to give a more specific error message than is possible with the default construction of the parser. One way around this is to add an additional state to the parser which matches the desired structure, followed by a token which cannot ever be reached. We define UNREACHABLE for this purpose.
Suppose I actually wanted to add a new message that would only show when a more specific error is made; maybe I want a special message for when model followed by a declaration. To do this I need to change the parser grammar in src/frontent/parser.mly to split off a new error state for the situation I want to catch. It is important to make sure not to change the behavior of the parser, so I should guarantee that he new rule will never successfully be built by terminating it with a token that can never occur. For example, I could change model = MODELBLOCK LBRACE ... to model = MODELBLOCK LBRACE ... | MODELBLOCK REAL UNREACHABLE.
This is enough to create a new parser state with a different error message.
Much like after a change to the parser for a new feature, after creating a new parser state, you should run dune build @update_messsages to check the new entry and generate a error template in parser.messages.