package dune-rpc

  1. Overview
  2. Docs
Communicate with dune using rpc

Install 

dune-project
 Dependency

github.com Readme Changelog MIT License Edit opam file Versions (17)

Authors

  1. J
    Jane Street Group, LLC <opensource@janestreet.com>

Maintainers

  1. J
    Jane Street Group, LLC <opensource@janestreet.com>

Sources

dune-3.22.2.tbz
sha256=c2ccf8bc6b17afa47c450297357496303aa7c8680e329b79d98c68e35013a118
sha512=26d3df56a509c6e8937a9333944303bdd8800a41e1b869c3adfb76d1e1fe615b6ec41491d596bd5982e338dcf70b97c18f963f37bfbf2bd581cbd356f3d5f4e5

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

Module Dune_rpc_private.ConvSource

Bidirectional parsing of canonical s-expressions

Sourcetype ('a, 'k) t
Sourcetype values
Sourcetype 'a value = ('a, 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
Sourceval 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.

Sourceval iso_result : ('a, 'k) t -> ('a -> ('b, exn) result) -> ('b -> 'a) -> ('b, 'k) t
Sourceval 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
Sourceval three : ('a, fields) t -> ('b, fields) t -> ('c, fields) t -> ('a * 'b * 'c, fields) t
Sourceval four : ('a, fields) t -> ('b, fields) t -> ('c, fields) t -> ('d, fields) t -> ('a * 'b * 'c * 'd, fields) t
Sourceval five : ('a, fields) t -> ('b, fields) t -> ('c, fields) t -> ('d, fields) t -> ('e, fields) t -> ('a * 'b * 'c * 'd * 'e, fields) t
Sourceval 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
Sourceval 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
Sourceval 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
Sourceval 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 =
  1. | Parse_error of {
    1. message : string;
    2. payload : (string * Stdune.Sexp.t) list;
    }
  2. | 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
Sourceval 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