Legend:
Library
Module
Module type
Parameter
Class
Class type
module Node_info : sig ... end
type t = {
tree : ( Bonsai__Node_path.Map.Key.t, Bonsai__Node_path.t, Bonsai__Node_path.Map.Key.comparator_witness ) Core.Map_intf.Map.t;
dag : ( Bonsai__Node_path.Map.Key.t, Bonsai__Node_path.t list, Bonsai__Node_path.Map.Key.comparator_witness ) Core.Map_intf.Map.t;
info : ( Bonsai__Node_path.Map.Key.t, Node_info.t, Bonsai__Node_path.Map.Key.comparator_witness ) Core.Map_intf.Map.t;
}

There are a few models for understanding a Computation.t.

  • As the tree of data that gets manipulated at eval-time. This tree understanding is quite close to the lexical structure of the program that produced the tree, so the tree model is useful for understanding where in your program each node came from.
  • As the directed-acyclic-graph (DAG) which exposes the sharing of computation in the graph. This model is useful for checking that computations are not being needlessly computed twice (i.e. they are being shared). Note that the computation inside an Assoc has only one copy in this model, even though the computation must run for every single entry in the input map.
  • As the incremental graph produced by eval. We do not currently generate this version of the graph, since it cannot be determined by static analysis of the Bonsai graph.

We expose the first two of these models as the tree and dag properties, represented as a map from dependency(s) to dependent. In addition, we also expose a mapping of nodes to node metadata.

include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : ( int -> t ) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
val empty : t
val iter_graph_updates : ( 'model, 'static_action, 'dynamic_action, 'result ) Computation.t -> on_update:( t -> unit ) -> ( 'model, 'static_action, 'dynamic_action, 'result ) Computation.t

Iterate through a computation to build up a t with information about the graph. The Lazy portions of the graph are traversed lazily; thus, rather than putting the resulting t in the return value of this function, we require a callback for receiving all the updates, including the immediately traversed ones and the ones that are delayed by Lazy.

val iter_graph_updates_packed : 'a Computation.packed -> on_update:( t -> unit ) -> 'a Computation.packed