Module `Dune_rpc_private.Conv`Source

Bidirectional parsing of canonical s-expressions

Sourcetype ('a, 'k) t

Sourcetype values

Sourcetype 'a value = ('a, values) t

Sourceval sexp : (Stdune.Sexp.t, values) t

Sourceval int : (int, values) t

Sourceval float : (float, values) t

Sourceval unit : (unit, values) t

Sourceval char : (char, values) t

Sourceval string : (string, values) t

Sourceval list : ('a, values) t -> ('a list, values) t

Sourceval pair : ('a, values) t -> ('b, values) t -> ('a * 'b, values) t

Sourceval option : ('a, values) t -> ('a option, values) t

Source

val triple : 
  ('a, values) t ->
  ('b, values) t ->
  ('c, values) t ->
  ('a * 'b * 'c, values) t

Sourceval enum : (string * 'a) list -> ('a, values) t

Sourceval iso : ('a, 'k) t -> ('a -> 'b) -> ('b -> 'a) -> ('b, 'k) t

iso t to_ from creates a parser for a type 'b out of a parser for a type 'a, where 'a and 'b are isomorphic to one another. The functions to_ and from convert between the two types 'a and 'b. A typical approach for parsing record types is to convert them to/from tuples (via the three, four, etc. combinators) which can be parsed with record, and then use iso to convert the parser for a tuple type into a parser for the original record type.

Source

val iso_result : 
  ('a, 'k) t ->
  ('a -> ('b, exn) result) ->
  ('b -> 'a) ->
  ('b, 'k) t

Source

val version : 
  ?until:(int * int) ->
  ('a, 'k) t ->
  since:(int * int) ->
  ('a, 'k) t

parsing records

Sourcetype fields

Sourcetype 'a field

Sourceval required : ('a, values) t -> 'a field

Sourceval optional : ('a, values) t -> 'a option field

Sourceval field : string -> 'a field -> ('a, fields) t

Sourceval both : ('a, fields) t -> ('b, fields) t -> ('a * 'b, fields) t

Source

val three : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('a * 'b * 'c, fields) t

Source

val four : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('d, fields) t ->
  ('a * 'b * 'c * 'd, fields) t

Source

val five : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('d, fields) t ->
  ('e, fields) t ->
  ('a * 'b * 'c * 'd * 'e, fields) t

Source

val six : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('d, fields) t ->
  ('e, fields) t ->
  ('f, fields) t ->
  ('a * 'b * 'c * 'd * 'e * 'f, fields) t

Source

val seven : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('d, fields) t ->
  ('e, fields) t ->
  ('f, fields) t ->
  ('g, fields) t ->
  ('a * 'b * 'c * 'd * 'e * 'f * 'g, fields) t

Source

val eight : 
  ('a, fields) t ->
  ('b, fields) t ->
  ('c, fields) t ->
  ('d, fields) t ->
  ('e, fields) t ->
  ('f, fields) t ->
  ('g, fields) t ->
  ('h, fields) t ->
  ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h, fields) t

Sourceval record : ('a, fields) t -> ('a, values) t

Source

val either : 
  ('a, fields) t ->
  ('b, fields) t ->
  (('a, 'b) Stdune.Either.t, fields) t

parsing sums

Sourcetype ('a, 'arg) constr

Sourceval constr : string -> ('arg, values) t -> ('arg -> 'a) -> ('a, 'arg) constr

Sourcetype case

Sourceval case : 'arg -> ('a, 'arg) constr -> case

Sourcetype 'a econstr

Sourceval econstr : ('a, 'arg) constr -> 'a econstr

Sourceval sum : 'a econstr list -> ('a -> case) -> ('a, values) t

Sourcetype error =

| Parse_error of {
1. message : string;
2. payload : (string * Stdune.Sexp.t) list;
}
| Version_error of {
1. since : int * int;
2. until : (int * int) option;
3. message : string;
4. payload : (string * Stdune.Sexp.t) list;
}

conversion from/to

Sourceval error : error -> 'a

Sourceval dyn_of_error : error -> Dyn.t

Sourceval to_sexp : ('a, values) t -> 'a -> Stdune.Sexp.t

Source

val of_sexp : 
  ('a, values) t ->
  version:(int * int) ->
  Stdune.Sexp.t ->
  ('a, error) result

Sourceval fixpoint : (('a, 'k) t -> ('a, 'k) t) -> ('a, 'k) t

fixpoint f is a helper for creating parsers of recursive data structures such as ASTs. f is a function which returns a parser for a single node in the hierarchy, and f is passed a parser which it can use for parsing children of the current node. fixpoint f then returns a parser for the recursive data structure.

Sourceval sexp_for_digest : ('a, 'k) t -> Stdune.Sexp.t

Install

dune-project
Dependency

Authors

Maintainers

Sources

doc/dune-rpc.private/Dune_rpc_private/Conv/index.html

Module `Dune_rpc_private.Conv`Source

parsing records

parsing sums

package dune-rpc

Install

dune-project Dependency

Authors

Maintainers

Sources

doc/dune-rpc.private/Dune_rpc_private/Conv/index.html

Module Dune_rpc_private.ConvSource

parsing records

parsing sums

dune-project
Dependency

Module `Dune_rpc_private.Conv`Source