package rpc

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Type declarations

rpclib
- Rpc_empty_module
rpclib.async
- Rpc_async
  - GenClient
  - GenServer
  - M
rpclib.cmdliner
- Cmdlinergen
  - Gen
rpclib.core
- Codegen
  - Gen
  - Interface
  - Interfaces
  - Method
- Idl
  - DefaultError
  - Error
    
    Make
    
    T
  - GenClient
  - GenClientExn
  - GenClientExnRpc
    
    R
  - GenServer
  - GenServerExn
  - Interface
  - Param
  - RPC
  - RPCfunc
- Pythongen
- Rpc
- Rpc_genfake
- Rpcmarshal
rpclib.html
- Htmlgen
rpclib.json
- Jsonrpc
rpclib.lwt
- Rpc_lwt
  - GenClient
  - GenServer
  - M
rpclib.markdown
- Markdowngen
rpclib.unix
- Rpc_client
rpclib.xml
- Xmlrpc

Legend:
Library
Module
Module type
Parameter
Class
Class type

Type declarations

type _ basic =

| Int : int basic
| Int32 : int32 basic
| Int64 : int64 basic
| Bool : bool basic
| Float : float basic
| String : string basic
| Char : char basic

type _ typ =

| Basic : 'a basic -> 'a typ
| DateTime : string typ
| Array : 'a typ -> 'a array typ
| List : 'a typ -> 'a list typ
| Dict : 'a basic * 'b typ -> ('a * 'b) list typ
| Unit : unit typ
| Option : 'a typ -> 'a option typ
| Tuple : 'a typ * 'b typ -> ('a * 'b) typ
| Struct : 'a structure -> 'a typ
| Variant : 'a variant -> 'a typ

and 'a def = {

name : string;
description : string list;
ty : 'a typ;

}

and boxed_def =

| BoxedDef : 'a def -> boxed_def

and ('a, 's) field = {

fname : string;
fdescription : string list;
fversion : Version.t option;
field : 'a typ;
fdefault : 'a option;
fget : 's -> 'a;
fset : 'a -> 's -> 's;

}

and 'a boxed_field =

| BoxedField : ('a, 's) field -> 's boxed_field

and field_getter = {

fget : 'a. string -> 'a typ -> ('a, Rresult.R.msg) Result.result;

}

and 'a structure = {

sname : string;
fields : 'a boxed_field list;
version : Version.t option;
constructor : field_getter -> ('a, Rresult.R.msg) Result.result;

}

and ('a, 's) tag = {

tname : string;
tdescription : string list;
tversion : Version.t option;
tcontents : 'a typ;
tpreview : 's -> 'a option;
treview : 'a -> 's;

}

and 'a boxed_tag =

| BoxedTag : ('a, 's) tag -> 's boxed_tag

and tag_getter = {

tget : 'a. 'a typ -> ('a, Rresult.R.msg) Result.result;

}

and 'a variant = {

variants : 'a boxed_tag list;
vdefault : 'a option;
vversion : Version.t option;
vconstructor : string -> tag_getter -> ('a, Rresult.R.msg) Result.result;

}

val int : int def

val int32 : int32 def

val int64 : int64 def

val bool : bool def

val float : float def

val string : string def

val char : char def

val unit : unit def

val default_types : boxed_def list