package rpclib-async

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

rpclib-async
- Rpc_async
  - GenClient
  - GenServer
  - M

Legend:
Library
Module
Module type
Parameter
Class
Class type

Server generator similar to Idl.GenServer that uses Async.

Parameters

Signature

include Idl.RPC
  with type implementation = server_implementation
   and type 'a res = 'a -> unit
   and type ('a, 'b) comp = ('a, 'b) Result.result M.async

type implementation = server_implementation

The implementation is dependent on the module, and represents the 'result' of the entire module. For example, in the Server module, the `implementation` is the server function, with type

Rpc.call -> Rpc.response.

For the Client module, the individual declarations are used to perform the RPCs, and the 'implementation' type is simply unit.

val implement : Idl.Interface.description -> implementation

To actually construct the implementation, an interface description must be provided

type 'a res = 'a -> unit

'a res is the result type of declaring a function. For example, the Client module, given an (int -> int -> int) fn, will return a function of type 'a - in this case, (int -> int -> int)

type ('a, 'b) comp = ('a, 'b) Result.result M.async

This is for inserting a type in between the function application and its result. For example, this could be an Lwt.t, meaning that the result of a function application is a thread

type _ fn

The GADT specifying the type of the RPC

val (@->) : 'a Idl.Param.t -> 'b fn -> ('a -> 'b) fn

This infix operator is for constructing function types

val returning : 'a Idl.Param.t -> 'b Idl.Error.t -> ('a, 'b) comp fn

This defines the return type of an RPC

val declare : string -> string list -> 'a fn -> 'a res

declare name description typ is how an RPC is declared to the module implementing the functionality. The return type is dependent upon the module being used