module type Handler = sig ... end
module type S = sig ... end
'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.
include Core.Monad.S with type 'a t := 'a t
t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does
t to yield a value
v, and then runs the computation returned by
module Monad_infix : sig ... end
val return : 'a -> 'a t
return v returns the (trivial) computation that returns v.
ignore_m t is
map t ~f:(fun _ -> ()).
ignore_m used to be called
ignore, but we decided that was a bad name, because it shadowed the widely used
Caml.ignore. Some monads still do
let ignore = ignore_m for historical reasons.
all, but ensures that every monadic value in the list produces a unit value, all of which are discarded rather than being collected into a list.
module Let_syntax : sig ... end
These are convenient to have in scope when programming with a monad:
val never : 'a t
An effect that never completes
val 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.
val print_s : Core.Sexp.t -> unit t
Prints the sexp when scheduled.
val 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
module Expert : sig ... end
module Private : sig ... end
module For_testing : sig ... end