dune 1.5.0 · OCaml Package

type ast = Ast.t =

| Atom of Stdune.Loc.t * Atom.t
| Quoted_string of Stdune.Loc.t * string
| Template of Template.t
| List of Stdune.Loc.t * ast list

type hint = {

on : string;
candidates : string list;

}

exception Decoder of Stdune.Loc.t * string * hint option

type ('a, 'kind) parser

Monad producing a value of type 'a by parsing an input composed of a sequence of S-expressions.

The input can be seen either as a plain sequence of S-expressions or a list of fields. The 'kind parameter indicates how the input is seen:

with
```
'kind = [values]
```
, the input is seen as an ordered sequence of S-expressions

with
```
'kind = [fields]
```
, the input is seen as an unordered sequence of fields

A field is a S-expression of the form: (<atom> <values>...) where atom is a plain atom, i.e. not a quoted string and not containing variables. values is a sequence of zero, one or more S-expressions.

It is possible to switch between the two mode at any time using the appropriate combinator. Some primitives can be used in both mode while some are specific to one mode.

type values

type fields

type 'a t = ('a, values) parser

type 'a fields_parser = ('a, fields) parser

val parse : 'a t -> Stdune.Univ_map.t -> ast -> 'a

parse parser context sexp parse a S-expression using the following parser. The input consist of a single S-expression. context allows to pass extra information such as versions to individual parsers.

val return : 'a -> ('a, _) parser

val (>>=) : ('a, 'k) parser -> ('a -> ('b, 'k) parser) -> ('b, 'k) parser

val (>>|) : ('a, 'k) parser -> ('a -> 'b) -> ('b, 'k) parser

val (>>>) : (unit, 'k) parser -> ('a, 'k) parser -> ('a, 'k) parser

val map : ('a, 'k) parser -> f:('a -> 'b) -> ('b, 'k) parser

val try_ : ('a, 'k) parser -> (exn -> ('a, 'k) parser) -> ('a, 'k) parser

val get : 'a Stdune.Univ_map.Key.t -> ('a option, _) parser

Access to the context

val set : 'a Stdune.Univ_map.Key.t -> 'a -> ('b, 'k) parser -> ('b, 'k) parser

val get_all : (Stdune.Univ_map.t, _) parser

val set_many : Stdune.Univ_map.t -> ('a, 'k) parser -> ('a, 'k) parser

val loc : (Stdune.Loc.t, _) parser

Return the location of the list currently being parsed.

val if_eos : then_:('a, 'b) parser -> else_:('a, 'b) parser -> ('a, 'b) parser

End of sequence condition. Uses then_ if there are no more S-expressions to parse, else_ otherwise.

val if_list : then_:'a t -> else_:'a t -> 'a t

If the next element of the sequence is a list, parse it with then_, otherwise parse it with else_.

val if_paren_colon_form : 
  then_:((Stdune.Loc.t * string) -> 'a) t ->
  else_:'a t ->
  'a t

If the next element of the sequence is of the form (:<name> ...), use then_ to parse .... Otherwise use else_.

val keyword : string -> unit t

Expect the next element to be the following atom.

val match_keyword : (string * 'a t) list -> fallback:'a t -> 'a t

match_keyword [(k1, t1); (k2, t2); ...] ~fallback

inspects the next element of the input sequence. If it is an atom equal to one of k1, k2, ... then the corresponding parser is used to parse the rest of the sequence. Other fallback is used.

val until_keyword : 
  string ->
  before:'a t ->
  after:'b t ->
  ('a list * 'b option) t

Use before to parse elements until the keyword is reached. Then use after to parse the rest.

type kind =

| Values of Stdune.Loc.t * string option
| Fields of Stdune.Loc.t * string option

What is currently being parsed. The second argument is the atom at the beginnig of the list when inside a sum ... or field ....

val kind : (kind, _) parser

val repeat : 'a t -> 'a list t

repeat t use t to consume all remaning elements of the input until the end of sequence is reached.

val capture : ('a t -> 'a) t

Capture the rest of the input for later parsing

val enter : 'a t -> 'a t

enter t expect the next element of the input to be a list and parse its contents with t.

val fields : 'a fields_parser -> 'a t

fields fp converts the rest of the current input to a list of fields and parse them with fp. This operation fails if one the S-expression in the input is not of the form (<atom> <values>...)

val record : 'a fields_parser -> 'a t

record fp = enter (fields fp)

Consume the next element of the input as a string, int, char, ...

include Stdune.Sexp_intf.Combinators with type 'a t := 'a t

val unit : unit t

val string : string t

val int : int t

val float : float t

val bool : bool t

val pair : 'a t -> 'b t -> ('a * 'b) t

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

val list : 'a t -> 'a list t

val array : 'a t -> 'a array t

val option : 'a t -> 'a option t

val raw : ast t

Unparsed next element of the input

val peek : ast option t

Inspect the next element of the input without consuming it

val peek_exn : ast t

Same as peek but fail if the end of input is reached

val junk : unit t

Consume and ignore the next element of the input

val junk_everything : (unit, _) parser

Ignore all the rest of the input

val plain_string : (loc:Stdune.Loc.t -> string -> 'a) -> 'a t

plain_string f expects the next element of the input to be a plain string, i.e. either an atom or a quoted string, but not a template nor a list.

val fix : ('a t -> 'a t) -> 'a t

val of_sexp_error : ?hint:hint -> Stdune.Loc.t -> string -> _

val of_sexp_errorf : 
  ?hint:hint ->
  Stdune.Loc.t ->
  ('a, unit, string, 'b) format4 ->
  'a

val no_templates : 
  ?hint:hint ->
  Stdune.Loc.t ->
  ('a, unit, string, 'b) format4 ->
  'a

val located : ('a, 'k) parser -> (Stdune.Loc.t * 'a, 'k) parser

val enum : (string * 'a) list -> 'a t

val sum : (string * 'a t) list -> 'a t

Parser that parse a S-expression of the form (<atom> <s-exp1> <s-exp2> ...) or <atom>. <atom> is looked up in the list and the remaining s-expressions are parsed using the corresponding list parser.

val map_validate : 
  'a fields_parser ->
  f:('a -> ('b, string) Stdune.Result.t) ->
  'b fields_parser

Check the result of a list parser, and raise a properly located error in case of failure.

Parsing record fields

val field : 
  string ->
  ?default:'a ->
  ?on_dup:(Stdune.Univ_map.t -> string -> Ast.t list -> unit) ->
  'a t ->
  'a fields_parser

val field_o : 
  string ->
  ?on_dup:(Stdune.Univ_map.t -> string -> Ast.t list -> unit) ->
  'a t ->
  'a option fields_parser

val field_b : 
  ?check:unit t ->
  ?on_dup:(Stdune.Univ_map.t -> string -> Ast.t list -> unit) ->
  string ->
  bool fields_parser

val field_o_b : 
  ?check:unit t ->
  ?on_dup:(Stdune.Univ_map.t -> string -> Ast.t list -> unit) ->
  string ->
  bool option fields_parser

val multi_field : string -> 'a t -> 'a list fields_parser

A field that can appear multiple times

val field_present_too_many_times : 
  Stdune.Univ_map.t ->
  string ->
  Ast.t list ->
  _

Default value for on_dup. It fails with an appropriate error message.

module Let_syntax : sig ... end

package dune

Parsing record fields