Generic (p.bonsai.v0.14.0.doc.bonsai.Bonsai.Generic)

type on_action_mismatch = [

| `Ignore
| `Raise
| `Warn

]

type ('input, 'result, 'incr, 'event) t =
  ('input, 'result, 'incr, 'event) Bonsai_types.Packed.t

The component type (('input, 'result) Bonsai.t) can be thought of as a function from 'model to 'result, but where the 'result can schedule events of the component's "action type". These actions are used to produce a new 'model which in turn causes the 'result to be recomputed. Instances of the 'result type can contain callbacks which schedule actions when interacted with by user (via button click, text input, etc). These actions are handled by the component's apply_action function, which yields a new model to be displayed.

type ('input, 'result, 'incr, 'event) nonexpert_t :=
  ('input, 'result, 'incr, 'event) t

val sexp_of_t : (_, _, _, _) t -> Core_kernel.Sexp.t

Component Constructors

val const : 'result -> (_, 'result, 'incr, _) t

Returns a component with no action or model, only a constant result.

val pure : f:('input -> 'result) -> ('input, 'result, _, _) t

A pure function with no model from 'input to 'result

val leaf : 
  (module Bonsai_types.Model with type t = 'model) ->
  (module Bonsai_types.Action with type t = 'action) ->
  name:string ->
  default_model:'model ->
  apply_action:
    (inject:('action -> 'event) ->
      schedule_event:('event -> unit) ->
      'input ->
      'model ->
      'action ->
      'model) ->
  compute:(inject:('action -> 'event) -> 'input -> 'model -> 'result) ->
  ('input, 'result, 'incr, 'event) t

Creates a leaf-node on the Bonsai tree. A leaf node has computation (via the compute parameter) and behavior (via the apply_action parameter).

Additionally name and sexp_of_action are provided to add some hooks for improved debugability.

val compose : 
  ('i1, 'r1, 'incr, 'event) t ->
  ('r1, 'r2, 'incr, 'event) t ->
  ('i1, 'r2, 'incr, 'event) t

compose a b joins a and b together such that the result of a is used as the input of b.

module type Enum = sig ... end

val enum : 
  (module Enum with type t = 'key) ->
  which:('input -> 'key) ->
  handle:('key -> ('input, 'result, 'incr, 'event) t) ->
  ('input, 'result, 'incr, 'event) t

val if_ : 
  ('input -> bool) ->
  then_:('input, 'result, 'incr, 'event) t ->
  else_:('input, 'result, 'incr, 'event) t ->
  ('input, 'result, 'incr, 'event) t

if_ is a simple application of enum to (module Bool).

module Infix : sig ... end

val map : 
  ('input, 'r1, 'incr, 'event) t ->
  f:('r1 -> 'r2) ->
  ('input, 'r2, 'incr, 'event) t

val map_input : 
  ('i2, 'result, 'incr, 'event) t ->
  f:('i1 -> 'i2) ->
  ('i1, 'result, 'incr, 'event) t

Transforms the input of a component. The signature of f is reversed from most other map functions.

module Proc : sig ... end

module Let_syntax : sig ... end

module Expert : sig ... end

The underlying representations of Bonsai components. This module is provided "as is", without warranty of any kind, express or implied...

Combinators

val state_machine : 
  (module Bonsai_types.Model with type t = 'model) ->
  (module Bonsai_types.Action with type t = 'action) ->
  Core_kernel.Source_code_position.t ->
  default_model:'model ->
  apply_action:
    (inject:('action -> 'event) ->
      schedule_event:('event -> unit) ->
      'input ->
      'model ->
      'action ->
      'model) ->
  ('input, 'model * ('action -> 'event), 'incr, 'event) t

module Map : sig ... end

module List_deprecated : sig ... end

Projecting over lists in Bonsai is fraught with issues. 1. Incremental can't be optimized for linked-list data structures. 2. Using list-index as the method for routing actions to components is basically never what you actually want, causing mis-delivery of events every time that the list changes.

module Arrow : sig ... end

('i, _, 'r) t is an arrow from 'i to 'r.

module With_incr : sig ... end