module Pipe_rpc: sig .. end
type ('query, 'response, 'error) t
module Id: sig .. end
val create : name:string ->
version:int ->
bin_query:'query Bin_prot.Type_class.t ->
bin_response:'response Bin_prot.Type_class.t ->
bin_error:'error Bin_prot.Type_class.t ->
('query, 'response, 'error) t
val bin_query : ('query, 'a, 'b) t -> 'query Bin_prot.Type_class.t
val bin_response : ('a, 'response, 'b) t ->
'response Bin_prot.Type_class.t
val bin_error : ('a, 'b, 'error) t -> 'error Bin_prot.Type_class.t
val implement : ('query, 'response, 'error) t ->
('connection_state ->
'query ->
aborted:unit Import.Deferred.t ->
('response Import.Pipe.Reader.t, 'error) Core.Std.Result.t Import.Deferred.t) ->
'connection_state Rpc.Implementation.t
val dispatch : ('query, 'response, 'error) t ->
Rpc.Connection.t ->
'query ->
('response Import.Pipe.Reader.t * Id.t, 'error)
Core.Std.Result.t Core.Std.Or_error.t Import.Deferred.t
This has (..., 'error) Result.t as its return type to represent the possibility of
the call itself being somehow erroneous (but understood - the outer Or_error.t
encompasses failures of that nature). Note that this cannot be done simply by making
'response a result type, since ('response Pipe.Reader.t, 'error) Result.t is
distinct from ('response, 'error) Result.t Pipe.Reader.t.
val dispatch_exn : ('query, 'response, 'error) t ->
Rpc.Connection.t ->
'query ->
('response Import.Pipe.Reader.t * Id.t) Import.Deferred.t
val abort : ('a, 'b, 'c) t -> Rpc.Connection.t -> Id.t -> unit
abort rpc connection id given an RPC and the id returned as part of a call to
dispatch, abort requests that the other side of the connection stop sending
updates.
val name : ('a, 'b, 'c) t -> string
val version : ('a, 'b, 'c) t -> int