To focus the search input from anywhere on the page, press the 'S' key.
in-package search v0.1.0
An Async extension of
Core_kernel.Bus. Functions that share the same name and types as those in
Core_kernel.Bus are direct calls to same.
include module type of struct include Core_kernel.Bus end
module Callback_arity = Core_kernel.Bus.Callback_arity
Callback_arity states the type of callbacks stored in a bus. Using
Callback_arity is an implementation technique that allows callbacks to be defined as ordinary n-ary curried functions (e.g.,
a1 -> a2 -> a3 -> r), instead of forcing n-ary-variadic callbacks to use tuples (e.g.,
a1 * a2 * a3 -> r). This also avoids extra allocation.
type ('callback, 'phantom) t = ('callback, 'phantom) Core_kernel.Bus.t
val sexp_of_t : ('callback -> Ppx_sexp_conv_lib.Sexp.t) -> ('phantom -> Ppx_sexp_conv_lib.Sexp.t) -> ('callback, 'phantom) t -> Ppx_sexp_conv_lib.Sexp.t
type ('callback, 'phantom) bus = ('callback, 'phantom) t
module Read_write = Core_kernel.Bus.Read_write
module Read_only = Core_kernel.Bus.Read_only
module On_subscription_after_first_write = Core_kernel.Bus.On_subscription_after_first_write
val read_only : ('callback, _) t -> 'callback Read_only.t
val create : ?name:Core_kernel.Info.t -> Core_kernel.Source_code_position.t -> 'callback Callback_arity.t -> on_subscription_after_first_write:On_subscription_after_first_write.t -> on_callback_raise:(Core_kernel.Error.t -> Base.Unit.t) -> 'callback Read_write.t
create [%here] ArityN ~on_subscription_after_first_write ~on_callback_raise,
[%here] is stored in the resulting bus, and contained in
%sexp_of: t, which can help with debugging.
subscribe_exn will raise if it is called after
write has been called the first time. If
Allow_and_send_last_value, then the bus will remember the last value written and will send it to new subscribers.
If a callback raises,
on_callback_raise is called with an error containing the exception.
on_callback_raise raises, then the exception is raised to
write and the bus is closed.
val callback_arity : ('callback, _) t -> 'callback Callback_arity.t
val num_subscribers : (_, _) t -> Base.Int.t
val is_closed : (_, _) t -> Base.Bool.t
val close : 'callback Read_write.t -> Base.Unit.t
close disallows future
writes -- once
close t is called, all further calls to
write t will raise.
close is idempotent. If
close is called from within a callback, the current message will still be sent to all subscribed callbacks that have not yet seen it before the close takes effect.
write4 call all callbacks currently subscribed to the bus, with no guarantee on the order in which they will be called.
write is non-allocating, though the callbacks themselves may allocate. Calling
writeN t from within a callback on
is_closed t will raise.
val write : ('a -> Base.Unit.t) Read_write.t -> 'a -> Base.Unit.t
val write2 : ('a -> 'b -> Base.Unit.t) Read_write.t -> 'a -> 'b -> Base.Unit.t
val write3 : ('a -> 'b -> 'c -> Base.Unit.t) Read_write.t -> 'a -> 'b -> 'c -> Base.Unit.t
val write4 : ('a -> 'b -> 'c -> 'd -> Base.Unit.t) Read_write.t -> 'a -> 'b -> 'c -> 'd -> Base.Unit.t
module Subscriber = Core_kernel.Bus.Subscriber
val subscribe_exn : ?extract_exn:Base.Bool.t -> ?on_callback_raise:(Core_kernel.Error.t -> Base.Unit.t) -> ?on_close:(Base.Unit.t -> Base.Unit.t) -> 'callback Read_only.t -> Core_kernel.Source_code_position.t -> f:'callback -> 'callback Subscriber.t
subscribe_exn t [%here] ~f adds the callback
f to the set of
t's subscribers, and returns a
Subscriber.t that can later be used to
[%here] is stored in the
Subscriber.t, and contained in
%sexp_of: Subscriber.t, which can help with debugging. If
subscribe_exn t is called by a callback in
t, i.e., during
write t, the subscription takes effect for the next
write, but does not affect the current
subscribe_exn takes time proportional to the number of callbacks.
on_callback_raise is supplied, then it will be called by
f raises; only if that subsequently raises will
on_callback_raise be called. If
on_callback_raise is not supplied, then
on_callback_raise will be called whenever
on_callback_raise is supplied and
extract_exn is set to true, then the error passed to the
on_callback_raise method will contain only the exception raised by
f without any additional information about the bus subscription or backtrace.
on_close is called if you are still subscribed when
Bus.close is called.
val iter_exn : 'callback Read_only.t -> Core_kernel.Source_code_position.t -> f:'callback -> Base.Unit.t
iter_exn t [%here] ~f is
ignore (subscribe_exn t [%here] ~callback:f). This captures the common usage in which one never wants to unsubscribe from a bus.
module Fold_arity = Core_kernel.Bus.Fold_arity
val fold_exn : 'callback Read_only.t -> Core_kernel.Source_code_position.t -> ('callback, 'f, 's) Fold_arity.t -> init:'s -> f:'f -> Base.Unit.t
fold_exn t [%here] arity ~init ~f folds over the bus events, threading a state value to every call. It is otherwise similar to
val unsubscribe : 'callback Read_only.t -> 'callback Subscriber.t -> Base.Unit.t
unsubscribe t subscriber removes the callback corresponding to
unsubscribe never raises and is idempotent. As with
unsubscribe t during
write t takes effect after the current
write finishes. Also like
unsubscribe takes time proportional to the number of callbacks.
val pipe1_exn : ('a -> unit) Read_only.t -> Core.Source_code_position.t -> 'a Async_kernel.Pipe.Reader.t
pipe1_exn t returns a pipe of updates from
t by subscribing to
t. Closing the pipe unsubscribes from
t closes the pipe.
pipe1_exn raises in the same circumstances as
module First_arity : sig ... end
val first_exn : ?stop:unit Async_kernel.Deferred.t -> 'c Read_only.t -> Core.Source_code_position.t -> ('c, 'f, 'r) First_arity.t -> f:'f -> 'r Async_kernel.Deferred.t
first_exn here t arity ~f returns a deferred that becomes determined with value
r when the first event is published to
first_exn then unsubscribes from
t, ensuring that
f is never called again after it returns
first_exn raises if it can't subscribe to the bus, i.e., if
subscribe_exn raises. If
f raises, then
first_exn raises to the monitor in effect when
first_exn was called.
first_exn takes time proportional to the number of bus subscribers.
stop is provided and becomes determined,
f will not be called again, it will unsubscribe from the bus, and the deferred that was returned by
first_exn will never become determined.