Module Core_kernel__.Bus
module Callback_arity : sig ... end
Callback_arity
states the type of callbacks stored in a bus. UsingCallback_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.
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 : sig ... end
module Read_only : sig ... end
module On_subscription_after_first_write : sig ... end
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 -> Core_kernel__.Import.unit) -> 'callback Read_write.t
In
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.If
on_subscription_after_first_write
isRaise
, thensubscribe_exn
will raise if it is called afterwrite
has been called the first time. Ifon_subscription_after_first_write
isAllow_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.If
on_callback_raise
raises, then the exception is raised towrite
and the bus is closed.
val callback_arity : ('callback, _) t -> 'callback Callback_arity.t
val num_subscribers : (_, _) t -> Core_kernel__.Import.int
val is_closed : (_, _) t -> Core_kernel__.Import.bool
val close : 'callback Read_write.t -> Core_kernel__.Import.unit
close
disallows futurewrite
s -- onceclose t
is called, all further calls towrite t
will raise.close
is idempotent. Ifclose
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.
val write : ('a -> Core_kernel__.Import.unit) Read_write.t -> 'a -> Core_kernel__.Import.unit
val write2 : ('a -> 'b -> Core_kernel__.Import.unit) Read_write.t -> 'a -> 'b -> Core_kernel__.Import.unit
val write3 : ('a -> 'b -> 'c -> Core_kernel__.Import.unit) Read_write.t -> 'a -> 'b -> 'c -> Core_kernel__.Import.unit
val write4 : ('a -> 'b -> 'c -> 'd -> Core_kernel__.Import.unit) Read_write.t -> 'a -> 'b -> 'c -> 'd -> Core_kernel__.Import.unit
module Subscriber : sig ... end
val subscribe_exn : ?extract_exn:Core_kernel__.Import.bool -> ?on_callback_raise:(Core_kernel.Error.t -> Core_kernel__.Import.unit) -> ?on_close:(Core_kernel__.Import.unit -> Core_kernel__.Import.unit) -> 'callback Read_only.t -> Core_kernel.Source_code_position.t -> f:'callback -> 'callback Subscriber.t
subscribe_exn t [%here] ~f
adds the callbackf
to the set oft
's subscribers, and returns aSubscriber.t
that can later be used tounsubscribe
.[%here]
is stored in theSubscriber.t
, and contained in%sexp_of: Subscriber.t
, which can help with debugging. Ifsubscribe_exn t
is called by a callback int
, i.e., duringwrite t
, the subscription takes effect for the nextwrite
, but does not affect the currentwrite
.subscribe_exn
takes time proportional to the number of callbacks.If
on_callback_raise
is supplied, then it will be called bywrite
wheneverf
raises; only if that subsequently raises willt
'son_callback_raise
be called. Ifon_callback_raise
is not supplied, thent
'son_callback_raise
will be called wheneverf
raises.If
on_callback_raise
is supplied andextract_exn
is set to true, then the error passed to theon_callback_raise
method will contain only the exception raised byf
without any additional information about the bus subscription or backtrace.on_close
is called if you are still subscribed whenBus.close
is called.
val iter_exn : 'callback Read_only.t -> Core_kernel.Source_code_position.t -> f:'callback -> Core_kernel__.Import.unit
iter_exn t [%here] ~f
isignore (subscribe_exn t [%here] ~callback:f)
. This captures the common usage in which one never wants to unsubscribe from a bus.
module Fold_arity : sig ... end
val fold_exn : 'callback Read_only.t -> Core_kernel.Source_code_position.t -> ('callback, 'f, 's) Fold_arity.t -> init:'s -> f:'f -> Core_kernel__.Import.unit
fold_exn t [%here] arity ~init ~f
folds over the bus events, threading a state value to every call. It is otherwise similar toiter_exn
.
val unsubscribe : 'callback Read_only.t -> 'callback Subscriber.t -> Core_kernel__.Import.unit
unsubscribe t subscriber
removes the callback corresponding tosubscriber
fromt
.unsubscribe
never raises and is idempotent. As withsubscribe_exn
,unsubscribe t
duringwrite t
takes effect after the currentwrite
finishes. Also likesubscribe_exn
,unsubscribe
takes time proportional to the number of callbacks.