package incremental

  1. Overview
  2. Docs
package incremental
Legend:
Library
Module
Module type
Parameter
Class
Class type

Make returns a new incremental implementation. Make uses Config.Default ().

Parameters

Signature

type state_witness
val sexp_of_state_witness : state_witness -> Sexplib0.Sexp.t
include S_gen with type 'a t = ('a, state_witness) incremental with type Before_or_after.t = Before_or_after.t with type Clock.t = state_witness Clock.t with type 'a Cutoff.t = 'a Cutoff.t with type 'a Expert.Dependency.t = ('a, state_witness) Expert.Dependency.t with type 'a Expert.Node.t = ('a, state_witness) Expert.Node.t with type Expert.Step_result.t = Expert.Step_result.t with type 'a Observer.t = ('a, state_witness) Observer.t with type 'a Observer.Update.t = 'a Observer.Update.t with type Packed.t = Packed.t with type Scope.t = state_witness Scope.t with type State.t = state_witness State.t with type State.Stats.t = State.Stats.t with type ('a, 'b) Unordered_array_fold_update.t = ('a, 'b) Unordered_array_fold_update.t with type 'a Update.t = 'a Update.t with type 'a Var.t = ('a, state_witness) Var.t
module State : sig ... end
type 'a t = ('a, state_witness) incremental
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
type 'a incremental := 'a t
include Core.Invariant.S1 with type 'a t := 'a t
val invariant : ('a -> unit) -> 'a t -> unit
val is_const : _ t -> bool
val is_valid : _ t -> bool
val is_necessary : _ t -> bool
val const : 'a -> 'a t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
val map2 : 'a1 t -> 'a2 t -> f:('a1 -> 'a2 -> 'b) -> 'b t
val map3 : 'a1 t -> 'a2 t -> 'a3 t -> f:('a1 -> 'a2 -> 'a3 -> 'b) -> 'b t
val map4 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'b) -> 'b t
val map5 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'b) -> 'b t
val map6 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'b) -> 'b t
val map7 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'b) -> 'b t
val map8 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'b) -> 'b t
val map9 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'b) -> 'b t
val map10 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'b) -> 'b t
val map11 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> 'a11 t -> f: ('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'b) -> 'b t
val map12 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> 'a11 t -> 'a12 t -> f: ('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> 'b) -> 'b t
val map13 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> 'a11 t -> 'a12 t -> 'a13 t -> f: ('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> 'a13 -> 'b) -> 'b t
val map14 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> 'a11 t -> 'a12 t -> 'a13 t -> 'a14 t -> f: ('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> 'a13 -> 'a14 -> 'b) -> 'b t
val map15 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> 'a5 t -> 'a6 t -> 'a7 t -> 'a8 t -> 'a9 t -> 'a10 t -> 'a11 t -> 'a12 t -> 'a13 t -> 'a14 t -> 'a15 t -> f: ('a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> 'a9 -> 'a10 -> 'a11 -> 'a12 -> 'a13 -> 'a14 -> 'a15 -> 'b) -> 'b t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val bind2 : 'a1 t -> 'a2 t -> f:('a1 -> 'a2 -> 'b t) -> 'b t
val bind3 : 'a1 t -> 'a2 t -> 'a3 t -> f:('a1 -> 'a2 -> 'a3 -> 'b t) -> 'b t
val bind4 : 'a1 t -> 'a2 t -> 'a3 t -> 'a4 t -> f:('a1 -> 'a2 -> 'a3 -> 'a4 -> 'b t) -> 'b t
module Infix : sig ... end
val join : 'a t t -> 'a t
val if_ : bool t -> then_:'a t -> else_:'a t -> 'a t
val freeze : ?when_:('a -> bool) -> 'a t -> 'a t
val depend_on : 'a t -> depend_on:_ t -> 'a t
val necessary_if_alive : 'a t -> 'a t
val for_all : bool t array -> bool t
val exists : bool t array -> bool t
val all : 'a t list -> 'a list t
val both : 'a t -> 'b t -> ('a * 'b) t
val array_fold : 'a t array -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val reduce_balanced : 'a t array -> f:('a -> 'b) -> reduce:('b -> 'b -> 'b) -> 'b t option
module Unordered_array_fold_update : sig ... end
val unordered_array_fold : ?full_compute_every_n_changes:int -> 'a t array -> init:'b -> f:('b -> 'a -> 'b) -> update:('a, 'b) Unordered_array_fold_update.t -> 'b t
val opt_unordered_array_fold : ?full_compute_every_n_changes:int -> 'a option t array -> init:'b -> f:('b -> 'a -> 'b) -> f_inverse:('b -> 'a -> 'b) -> 'b option t
val sum : ?full_compute_every_n_changes:int -> 'a t array -> zero:'a -> add:('a -> 'a -> 'a) -> sub:('a -> 'a -> 'a) -> 'a t
val opt_sum : ?full_compute_every_n_changes:int -> 'a option t array -> zero:'a -> add:('a -> 'a -> 'a) -> sub:('a -> 'a -> 'a) -> 'a option t
val sum_int : int t array -> int t
val sum_float : float t array -> float t
module Scope : sig ... end
module Var : sig ... end
module Observer : sig ... end
val observe : ?should_finalize:bool -> 'a t -> 'a Observer.t
module Update : sig ... end
val on_update : 'a t -> f:('a Update.t -> unit) -> unit
val stabilize : unit -> unit
val am_stabilizing : unit -> bool
module Cutoff : sig ... end
val set_cutoff : 'a t -> 'a Cutoff.t -> unit
val get_cutoff : 'a t -> 'a Cutoff.t
val lazy_from_fun : (unit -> 'a) -> 'a Core.Lazy.t
val default_hash_table_initial_size : int
val memoize_fun : ?initial_size:int -> 'a Base.Hashtbl.Key.t -> ('a -> 'b) -> ('a -> 'b) Core.Staged.t
val memoize_fun_by_key : ?initial_size:int -> 'key Base.Hashtbl.Key.t -> ('a -> 'key) -> ('a -> 'b) -> ('a -> 'b) Core.Staged.t
val weak_memoize_fun : ?initial_size:int -> 'a Base.Hashtbl.Key.t -> ('a -> 'b Core.Heap_block.t) -> ('a -> 'b Core.Heap_block.t) Core.Staged.t
val weak_memoize_fun_by_key : ?initial_size:int -> 'key Base.Hashtbl.Key.t -> ('a -> 'key) -> ('a -> 'b Core.Heap_block.t) -> ('a -> 'b Core.Heap_block.t) Core.Staged.t
val user_info : _ t -> Core.Info.t option
val set_user_info : _ t -> Core.Info.t option -> unit
val append_user_info_graphviz : _ t -> label:string list -> attrs:string Core.String.Map.t -> unit
module Node_value : sig ... end
val node_value : 'a t -> 'a Node_value.t

node_value t returns whatever value t happens to have in it, regardless of whether t is valid, necessary, or stale. One should use observe for a more sensible semantics, reserving node_value for debugging.

module Packed : sig ... end
val pack : _ t -> Packed.t
val save_dot : ?emit_bind_edges:bool -> Core.Out_channel.t -> unit
val save_dot_to_file : ?emit_bind_edges:bool -> string -> unit
module Let_syntax : sig ... end
module Before_or_after : sig ... end
module Step_function = Incremental_step_function
module Clock : sig ... end
module Expert : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct