package bonsai

You can search for identifiers within the package.

in-package search v0.2.0

A library for building dynamic webapps, using Js_of_ocaml

Install

Dune Dependency

github.com Readme MIT License Edit opam file Versions (6)

Authors

J

Jane Street Group, LLC

Maintainers

J

Jane Street developers

Sources

v0.15.1.tar.gz

sha256=0c4a714146073f421f1a6179561f836b45d8dc012c743207d3481ea63bef74bf

doc/bonsai.web/Bonsai_web/Effect/index.html

Module `Bonsai_web.Effect`Source

include module type of Virtual_dom.Vdom.Effect

include module type of struct include Ui_effect end

Sourcemodule type Handler = Virtual_dom.Vdom.Effect.Handler

Sourcetype 'a t = 'a Virtual_dom.Vdom.Effect.t = ..

'a Effect.t represents some computation of type 'a that can be performed outside of the typical computational/incremental structure of a Bonsai program . Examples of this computation might be:

Calling an RPC and getting the result back
Running expensive computation on a web-worker thread
Requesting some information from the imperative "Start.Handle"-holding code

If you have a value of type 'a Effect.t, you can schedule it to be run by calling inject and providing a function that will be called when the callback completes.

Sourcetype t +=

| Ignore : unit t
| Many : unit t list -> unit t

include Core.Monad.S with type 'a t := 'a t

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

val (>>|) : 'a t -> ('a -> 'b) -> 'b t

module Monad_infix = Ui_effect.Monad_infix

val bind : 'a t -> f:('a -> 'b t) -> 'b t

val return : 'a -> 'a t

val map : 'a t -> f:('a -> 'b) -> 'b t

val join : 'a t t -> 'a t

val ignore_m : 'a t -> unit t

val all : 'a t list -> 'a list t

val all_unit : unit t list -> unit t

module Let_syntax = Ui_effect.Let_syntax

Sourceval never : 'a t

An effect that never completes

Sourceval lazy_ : 'a t Core.Lazy.t -> 'a t

If creating an effect could be expensive, you can wrap its construction in a lazy and pass it to this function so that its construction will be deferred until it's about to be evaluated.

Sourceval print_s : Core.Sexp.t -> unit t

Prints the sexp when scheduled.

Sourceval of_sync_fun : ('query -> 'result) -> 'query -> 'result t

of_sync_fun is similar to of_deferred_fun but with a synchronous function instead of a deferred one. This can be used for functions that are synchronous but side-effecting, or as a mock-function in tests that replace the usages of of_deferred_fun in the actual app.

Note that, unlike of_deferred_fun, the function must return immediately, so it's not possible to test the behaviour of tour app between calling the function and the effect becoming 'determined'. If you need to do this, see of_svar and of_query_response_tracker below.

Sourcemodule Define = Ui_effect.Define

Sourcemodule Define1 = Ui_effect.Define1

Sourcemodule Private = Ui_effect.Private

Sourcemodule For_testing = Ui_effect.For_testing

Sourcemodule type Visibility_handler = Virtual_dom.Vdom.Effect.Visibility_handler

Sourcemodule type S = Virtual_dom.Vdom.Effect.S

Sourcetype t +=

| Viewport_changed
(*
Viewport_changed events are delivered to all visibility handlers
*)
| Stop_propagation
(*
Stop_propagation prevents the underlying DOM event from propagating up to the parent elements
*)
| Stop_immediate_propagation
(*
Stop_immediate_propagation causes sequence_as_sibling to ignore next sequenced event.
*)
| Prevent_default
(*
Prevent_default prevents the default browser action from occurring as a result of this event
*)

Sourceval sequence_as_sibling : unit t -> unless_stopped:(unit -> unit t) -> unit t

Sequences two events, but only if the first is neither Stop_immediate_propagation nor a Many which contains Stop_immediate_propagation. Use this instead of Many if combining events that are associated with the same source; for example, the motivation for this function is for merging Inputs of hooks.

The second argument is a function that takes unit not because it is expected to be impure, but because often it is computed via some arbitrary handler function. Using hooks as an example, often the input to a hook has type 'a -> Effect.t. To merge inputs f and g, you might write

  fun x -> sequence_as_sibling (f x) (g x)

but this might unnecessarily call g if f returns something with Stop_immediate_propagation. Instead, using this API, you must write

  fun x -> sequence_as_sibling (f x) (fun () -> (g x))

Sourcemodule Define_visibility = Virtual_dom.Vdom.Effect.Define_visibility

For registering a handler for Viewport_changed events. Note that if this functor is called multiple times, each handler will see all of the events.

Sourcemodule Expert = Virtual_dom.Vdom.Effect.Expert

Source

val of_deferred_fun : 
  ('query -> 'response Async_kernel.Deferred.t) ->
  'query ->
  'response t

of_deferred_fun is a way to convert from a deferred-returning function to an effect-returning function. This function is commonly used to wrap RPC calls. Memory is allocated permanently every time that of_deferred_fun is called, so be sure to re-use the function inside the Staged.t!