Module Async_rpc_kernel__Rpc.Rpc

type ('query, 'response) t
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
val implement' : ('query, 'response) t ‑> ('connection_state ‑> 'query ‑> 'response) ‑> 'connection_state Implementation.t

implement' is different from implement 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 with implement'.

val dispatch' : ('query, 'response) t ‑> Connection.t ‑> 'query ‑> 'response Async_rpc_kernel.Rpc_result.t Async_kernel.Deferred.t

dispatch' exposes Rpc_result.t as output. Passing it through rpc_result_to_or_error gives you the same result as dispatch

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