Represents a parser which can parse value 'a. Use parse functions to evaluate a parser.

return v always parses value v.

Examples

  module P = Reparse.String.String

  ;;
  let input = new P.string_input "" in
  let v1 = P.(parse input (return 5)) in
  let v2 = P.(parse input (return "hello")) in
  v1 = 5 && v2 = "hello"

unit always parses to ():unit value.

ignore p ignore any result from p upon success and return () instead.

fail err_msg returns a parser that always fails with err_msg.

Examples

  module P = Reparse.String

  ;;
  let input = new P.string_input "" in
  let r =
    try
      let _ = P.(parse input (fail "hello error")) in
      assert false
    with e -> e in
  r
  = P.Parser
      {offset= 0; line_number= 0; column_number= 0; msg= "hello error"}

bind f p is prefix version of p >>= f.

both p q is evaluates to (a,b) when a is evaluted from p and b is evaluated from q.

map f p is prefix version of p >>| f.

ppx_let syntax support module.

peek_char t parses the next character from input without consuming it. It fails if EOI is reached.

Examples

  module P = Reparse.String

  ;;
  let p = P.peek_char in
  let v = P.parse_string p "hello" in
  v = 'h'

Input is not consumed.

peek_char_opt is the exception safe version of peek_char. It returns an option rather than throwing exn when EOI is reached.

peek_string n parse a string of length n without consuming it.

Examples

  module P = Reparse.String
  open P

  ;;
  let p = P.peek_string 5 in
  let v = P.parse_string p "hello" in
  v = "hello"

Input is not consumed.

any_char parses the next character from input. Fails if input has reached end of input.

Examples

  module P = Reparse.String

  ;;
  let v = P.(parse_string any_char "hello") in
  v = 'h'

unsafe_any_char is same as any_char except the returned char value is not buffered by the input. Important don't use this parser with backtracking parsers such as <|>, alt, any etc.

Note Ensure you call trim_input_buffer after calling this parser.

char c parses character c exactly.

Examples

  module P = Reparse.String

  ;;
  let p = P.char 'h' in
  let v = P.parse_string p "hello" in
  v = 'h'

char_if f parses a character c if f c is true.

Examples

  module P = Reparse.String

  ;;
  let p = P.char_if (function 'a' -> true | _ -> false) in
  let v = P.parse_string p "abc" in
  v = 'a'

string_cs s parses a string s exactly. String comparison is case sensitive.

Examples

  module P = Reparse.String

  ;;
  let p = P.string_cs "hello" in
  let v = P.parse p (P.of_string "hello world") in
  v = "hello"

string_of_chars l converts char list l to string

Examples

  module P = Reparse.String

  ;;
  let p = P.(take ~sep_by:space next >>= string_of_chars) in
  let v = P.parse_string p "h e l l o" in
  v = "hello"

take_string n returns a string of length n exactly from input.

take_cstruct n returns a Cstruct.t of length n exactly from input. This is usually a zeor copy - depending on input of course - version of take_string.

any l parses the value of the first successful parser in list l. Specified parsers in l are evaluated sequentially from left to right. A failed parser doesn't consume any input, i.e. offset is unaffected. The parser fails if none of the parsers in l are evaluated successfully.

Examples

First successful parser result is returned

  module P = Reparse.String

  ;;
  let p = P.(any [char 'z'; char 'x'; char 'a']) in
  let v = P.parse_string p "zabc" in
  v = 'z'

  ;;
  let p = P.(any [char 'z'; char 'x'; char 'a']) in
  let v = P.parse_string p "xabc" in
  v = 'x'

  ;;
  let p = P.(any [char 'z'; char 'x'; char 'a']) in
  let v = P.parse_string p "abc" in
  v = 'a'

Parser fails when none of the parsers in l are successful.

  let p = P.(any [char 'z'; char 'x'; char 'a']) in
  let v =
    try
      let _ = P.parse_string p "yyy" in
      false
    with _ -> true in
  v = true

alt p q is p <|> q. See Reparse.Infix.((<|>))

optional p parses Some a if successful and None otherwise. a is the parsed value of p.

Examples

  module P = Reparse.String
  open P

  ;;
  let p = P.(optional (char 'a')) in
  let v = P.parse_string p "ab" in
  v = Some 'a'

  ;;
  let p = P.(optional (char 'z')) in
  let v = P.parse_string p "ab" in
  v = None

not_ p parses value () if and only if p fails to parse, otherwise the parse fails.

Examples

  module P = Reparse.String

  ;;
  let p = P.(not_ (char 'a')) in
  let v = P.parse_string p "bbb" in
  v = ()

is p parses true if p is successful, false otherwise. Note evaluation of p doesn't consume any input.

Examples

  module P = Reparse.String

  ;;
  let p = P.(is (char 'b')) in
  let v = P.parse_string p "bcb" in
  v = true

is_not p parses value true if p fails to parse and false otherwise. Note evaluating p doesn't consume any input.

Examples

  module P = Reparse.String

  ;;
  let p = P.(is_not (char 'a')) in
  let v = P.parse_string p "bbb" in
  v = true

recur f returns a recursive parser. Function value f accepts a parser p as its argument and returns a parser q. Parser q in its definition can refer to p and p can refer to q in its own definition. Such parsers are also known as a fixpoint or y combinator.

all parsers parses all parsers in parsers and returns a list of successful parse result. All of the parsers must succeed for all to succeed.

all_unit parsers parses parsers and discards their results. All of the parsers must succeed for all_unit to succeed.

skip ~at_least ~up_to p repeatedly parses p and discards its value. The lower and upper bound of repetition is specified by arguments at_least and up_to respectively. The default value of at_least is 0. The default value of up_to is unspecified, i.e. there is no upper limit. The repetition ends when one of the following occurs:

• p evaluates to failure
• up_to upper bound value is reached The parser encapsulates the count of times p was evaluated successfully.

Examples

  module P = Reparse.String

  ;;
  let p = P.(skip space) in
  let v = P.parse_string p "     " in
  v = 5

take ~at_least ~up_to ~sep_by p repeatedly parses p and returns the parsed values. The lower and upper bound of repetition is specified by arguments at_least and up_to respectively. The default value of at_least is 0. The default value of up_to is unspecified, i.e. there is no upper limit. If sep_by is specified then the evaluation of p must be followed by a successful evaluation of sep_by. The parsed value of sep_by is discarded. The repetition ends when one of the following occurs:

• p evaluates to failure
• sep_by evaluates to failure
• up_to upper boudn value is reached The parser fails if the count of repetition of p does not match the value specified by at_least.

Examples

Default behaviour.

  module P = Reparse.String

  ;;
  let p = P.(take (char 'a')) in
  let v = P.parse_string p "aaaaa" in
  v = ['a'; 'a'; 'a'; 'a'; 'a']

Specify ~sep_by.

  module P = Reparse.String

  ;;
  let p = P.(take ~sep_by:(char ',') (char 'a')) in
  let v = P.parse_string p "a,a,a,a,a" in
  v = ['a'; 'a'; 'a'; 'a'; 'a']

Specify lower bound argument at_least.

  module P = Reparse.String

  ;;
  let p = P.(take ~at_least:3 ~sep_by:(char ',') (char 'a')) in
  let v = P.parse_string p "a,a,a,a,a" in
  v = ['a'; 'a'; 'a'; 'a'; 'a']

Lower bound not met results in error.

  module P = Reparse.String

  ;;
  let p = P.(take ~at_least:5 ~sep_by:(char ',') (char 'a')) in
  let v =
    try
      let _ = P.parse_string p "a,a,a,a" in
      false
    with _ -> true in
  v = true

Specify upper bound up_to.

  module P = Reparse.String

  ;;
  let p = P.(take ~up_to:3 ~sep_by:(char ',') (char 'a')) in
  let v = P.parse_string p "a,a,a,a,a" in
  v = ['a'; 'a'; 'a']

take_while_cb ~sep_by ~while_ ~on_take p repeatedly parses p and calls callback on_take_cb with the parsed value. p is evaluated if and only if while_ evaluates to true. If sep_by is specified then the evaluation of p must be followed by a successful evaluation of sep_by. The parsed value of sep_by is discarded. p is evaluated repeatedly. The repetition ends when one of the following occurs: on_take_cb is the callback function that is called every time p is evaluated.

• p evaluates to failure
• while_ returns false
• sep_by evaluates to failure take_while_cb is the general version of Reparse.take_while. It allows to specify how the value a is to be collected. Note while_ does not consume input.

Examples

  module P = Reparse.String
  open P

  ;;
  let buf = Buffer.create 0 in
  let on_take_cb a = Buffer.add_char buf a in
  let p =
    P.(take_while_cb (char 'a') ~while_:(is_not (char 'b')) ~on_take_cb)
  in
  let v = P.parse_string p "aaab" in
  let s = Buffer.contents buf in
  v = 3 && s = "aaa"

take_while ~sep_by p ~while_ p repeatedly parses p and returns its value. p is evaluated if and only if while_ evaluates to true. If sep_by is specified then the evaluation of p must be followed by a successful evaluation of sep_by. The parsed value of sep_by is discarded. The repetition ends when one of the following occurs:

• p evaluates to failure
• while_ returns false
• sep_by evaluates to failure Note while_ does not consume input.

Examples

Default behaviour.

  module P = Reparse.String

  ;;
  let p = P.(take_while ~while_:(is_not (char 'b')) (char 'a')) in
  let v = P.parse_string p "aab" in
  v = ['a'; 'a']

Specify sep_by.

  module P = Reparse.String

  ;;
  let p =
    P.(
      take_while ~sep_by:(char ',') ~while_:(is_not (char 'b')) (char 'a'))
  in
  let v = P.parse_string p "a,a,ab" in
  v = ['a'; 'a'; 'a']

take_between ~sep_by ~start ~end_ p parses start and then repeatedly parses p while the parsed value of p doesn't equal to parsed value of end_. After the repetition end, it parses end_. The parser returns the list of parsed values of p. Both start and end_ parser values are discarded. If sep_by is specified then the evaluation of p must be followed by a successful evaluation of sep_by. The parsed value of sep_by is discarded. The repetition ends when one of the following occurs:

• p evaluates to failure
• end_ parsed value matches p parsed value
• sep_by evaluates to failure

Examples

  module P = Reparse.String

  ;;
  let p =
    P.(
      take_between ~sep_by:(char ',') ~start:(P.char '(') ~end_:(char ')')
        next) in
  let v = P.parse_string p "(a,a,a)" in
  v = ['a'; 'a'; 'a']

alpha parses a character in range A- Z or a-z.

Examples

  module P = Reparse
  open P

  ;;
  let p = P.(take alpha) in
  let v = P.parse_string p "abcdABCD" in
  v = ['a'; 'b'; 'c'; 'd'; 'A'; 'B'; 'C'; 'D']

alpha_num parses a character in range A-Z or a-z or 0-9.

Examples

  module P = Reparse
  open P

  ;;
  let p = P.(take alpha_num) in
  let v = P.parse_string p "ab123ABCD" in
  v = ['a'; 'b'; '1'; '2'; '3'; 'A'; 'B'; 'C'; 'D']

lower_alpha parses a character in range a-z.

Examples

  module P = Reparse
  open P

  ;;
  let p = P.(take lower_alpha) in
  let v = P.parse_string p "abcd" in
  v = ['a'; 'b'; 'c'; 'd']

upper_alpha parses a character in range A-Z.

Examples

  module P = Reparse
  open P

  ;;
  let p = P.(take upper_alpha) in
  let v = P.parse_string p "ABCD" in
  v = ['A'; 'B'; 'C'; 'D']

bit parses a character which is either '0' or '1'.

Examples

  module P = Reparse

  ;;
  let p = P.(take bit) in
  let v = P.parse_string p "0110 ab" in
  v = ['0'; '1'; '1'; '0']

ascii_char parses any US-ASCII character.

Examples

  module P = Reparse

  ;;
  let p = P.(take ascii_char) in
  let v = P.parse_string p "0110 abc '" in
  v = ['0'; '1'; '1'; '0'; ' '; 'a'; 'b'; 'c'; ' '; '\'']

cr parses character '\r'.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string cr "\rab") in
  v = '\r'

crlf parses string "\r\n".

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string crlf "\r\n abc") in
  v = "\r\n"

control parses characters in range 0x00 - 0x1F or character 0x7F.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string control "\x00") in
  v = '\x00'

digit parses one of the digit characters, 0 .. 9.

Examples

  module P = Reparse

  ;;
  let p = P.(take digit) in
  let v = P.parse_string p "0123456789a" in
  v = ['0'; '1'; '2'; '3'; '4'; '5'; '6'; '7'; '8'; '9']

digits parses one or more digit characters, 0 .. 9.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string digits "1234 +") in
  v = "1234"

dquote parses double quote character '"'.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string dquote "\"hello ") in
  v = '"'

hex_digit parses any of the hexadecimal digits - 0..9, A, B, C, D, E, F.

Examples

  module P = Reparse

  ;;
  let p = P.(take hex_digit) in
  let v = P.parse_string p "0ABCDEFa" in
  v = ['0'; 'A'; 'B'; 'C'; 'D'; 'E'; 'F']

htab parses a horizontal tab character '\t'.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string htab "\t") in
  v = '\t'

lf parses a linefeed '\n' character.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string lf "\n") in
  v = '\n'

octect parses any character in the range \x00 - \xFF. Synonym for Reparse.next

Examples

  module P = Reparse

  ;;
  let p = P.(take octet) in
  let v = P.parse_string p "0110 abc '" in
  v = ['0'; '1'; '1'; '0'; ' '; 'a'; 'b'; 'c'; ' '; '\'']

space parses a space character.

Examples

  module P = Reparse

  ;;
  let v = P.(parse_string space " abc '") in
  v = ' '

vchar parses any of the visible - printable - characters.

Examples

  module P = Reparse

  ;;
  let p = P.(take vchar) in
  let v = P.parse_string p "0110abc\x00" in
  v = ['0'; '1'; '1'; '0'; 'a'; 'b'; 'c']

whitespace parses a space ' ' or horizontal tab '\t' character.

Examples

  module P = Reparse

  ;;
  let p = P.(take whitespace) in
  let v = P.parse_string p "\t \t " in
  v = ['\t'; ' '; '\t'; ' ']

advance n advances input by n bytes.

eoi parses end of input. Fails if parser is not at end of input.

Examples

  module P = Reparse.String

  ;;
  let v = P.(parse_string eoi "") in
  v = ()

  ;;
  let v =
    try
      let _ = P.(parse_string eoi "a") in
      false
    with _ -> true in
  v = true

trim_input_buffer () calls INPUT.trim_buffer with the current parser position. Use this function to control the memory consumption of the input buffer.

Note Once trimmed the parser is unable to backtrack beyond the position of last_trimmed_pos. This may affect a correct functioning of <|> parser as it backtracks when trying various alternatives.

pos returns the current parser position.

last_trimmed_pos returns the last trimmed input position marker.

input_buffer_size returns current input buffer size in bytes if input is a buffered input otherwise it returns None for unbuffered input.