async_rpc_kernel

Platform-independent core of Async RPC library
package async_rpc_kernel
Legend:
Library
Module
Module type
Parameter
Class
Class type
Library async_rpc_kernel
Module Async_rpc_kernel . Rpc . Rpc
type ('query, 'response) t
val create : name:string -> version:int -> bin_query:'query Core_kernel.Bin_prot.Type_class.t -> bin_response:'response Core_kernel.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 Core_kernel.Bin_prot.Type_class.t
val bin_response : ( _, 'response ) t -> 'response Core_kernel.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 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 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