Module Async_rpc_kernel__Rpc.Rpc
val create : name:string -> version:int -> bin_query:'query Bin_prot.Type_class.t -> bin_response:'response Bin_prot.Type_class.t -> ('query, 'response) t
val name : (_, _) t -> string
the same values as were passed to create.
val version : (_, _) t -> int
val description : (_, _) t -> Description.t
val bin_query : ('query, _) t -> 'query Bin_prot.Type_class.t
val bin_response : (_, 'response) t -> 'response Bin_prot.Type_class.t
val implement : ('query, 'response) t -> ('connection_state -> 'query -> 'response Async_kernel.Deferred.t) -> 'connection_state Implementation.t
If the function that implements the RPC raises, the implementer does not see the exception. Instead, it is sent as an error to the caller of the RPC, i.e. the process that called
dispatch
or one of its alternatives.
val implement' : ('query, 'response) t -> ('connection_state -> 'query -> 'response) -> 'connection_state Implementation.t
implement'
is different fromimplement
in that:1.
'response
is immediately serialized and scheduled for delivery to the RPC dispatcher.2. Less allocation happens, as none of the Async-related machinery is necessary.
implement
also tries to do 1 when possible, but it is guaranteed to happen withimplement'
.
val dispatch' : ('query, 'response) t -> Connection.t -> 'query -> 'response Async_rpc_kernel.Rpc_result.t Async_kernel.Deferred.t
dispatch'
exposesRpc_result.t
as output. Passing it throughrpc_result_to_or_error
gives you the same result asdispatch
val rpc_result_to_or_error : ('query, 'response) t -> Connection.t -> 'response Async_rpc_kernel.Rpc_result.t -> 'response Core_kernel.Or_error.t
val dispatch : ('query, 'response) t -> Connection.t -> 'query -> 'response Core_kernel.Or_error.t Async_kernel.Deferred.t
val dispatch_exn : ('query, 'response) t -> Connection.t -> 'query -> 'response Async_kernel.Deferred.t
module Expert : sig ... end