@spec char_parser(maybe(atom() | binary() | list()), binary?()) :: Minipeg.Parser.t()

See Minipeg.Parsers.BasicParsers.char_parser/2.

@spec delimited_string_parser(binary(), binary(), boolean(), binary?()) ::
  Minipeg.Parser.t()

Parses any character in the specified set, defaulting to all characters

Succeeds if next char in input is in the specified set Fails if input is empty or next char is not in the specified set

If the specified charset is an atom it is interpreted as a POSIX character class described in the docs of the Regex module, here are the currently supported values:

  :alnum | :alpha | :blank | :cntrl | :digit | :graph | :lower | :print | :punct | :space | :upper | :word | :xdigit

@spec end_parser(binary?()) :: Minipeg.Parser.t()

Parser that only succeeds on empty input / end of input

@spec escaped_char_parser(binary?(), binary?(), char_set_spec_t()) ::
  Minipeg.Parser.t()

The escaped_char_parser parses a character after an escape returning only the escaped char

iex(1)> parse_string(escaped_char_parser(), "\\a")
{:ok, "a"}

However only escaped chars are parsed

iex(2)> {:error, _} = parse_string(escaped_char_parser(), "a")

The default escape character can be changed

iex(3)> parse_string(escaped_char_parser(","), ",b")
{:ok, "b"}

iex(4)> {:error, _} = parse_string(escaped_char_parser(","), "\\b")

@spec failure_parser(binary?(), binary?()) :: Minipeg.Parser.t()

This parser always fails

@spec ident_parser(binary?(), Keyword.t()) :: Minipeg.Parser.t()

See Minipeg.Parsers.CommonParsers.ident_parser/2.

@spec int_parser(binary?()) :: Minipeg.Parser.t()

See Minipeg.Parsers.CommonParsers.int_parser/1.

@spec keywords_parser([binary()], binary?()) :: Minipeg.Parser.t()

Succeeds if any of the given keywords parse

@spec literal_parser(binary(), binary?()) :: Minipeg.Parser.t()

Parses only an exact occurrance of the literal string

@spec many_chars_parser(maybe(binary() | list()), many_chars_options()) ::
  Minipeg.Parser.t()

Combines many characters into one string, this is a convenience for

    char_parser(...) |> many(...) |> map_to_string

By default many gets min set to 1

iex(5)> parse_string(many_chars_parser(), "a")
{:ok, "a"}

iex(6)> parse_string(many_chars_parser(), "")
{:error, "Missing 1 parses in many (in char_parser()) in <binary>:1,1"}

We can change the default minimum though

iex(7)> parse_string(many_chars_parser(nil, min: 2), "a")
{:error, "Missing 1 parses in many (in char_parser()) in <binary>:1,1"}

iex(8)> parse_string(many_chars_parser(nil, min: 2), "ab")
{:ok, "ab"}

iex(9)> parse_string(many_chars_parser(nil, min: 0), "")
{:ok, ""}

If we define a charset only characters from the set are parsed

iex(10)> parse_string(many_chars_parser("abc"), "axab")
{:ok, "a"}

iex(11)> {:error, _} = parse_string(many_chars_parser("abc"), "xab")

We can however use escape to allow any character

iex(12)> parser = many_chars_parser("ab")
...(12)> parse_string(parser, "\\xa\\bc")
{:ok, "xab"}

@spec many_not_chars_parser(binary() | list(), many_chars_options()) ::
  Minipeg.Parser.t()

This is the pendant to the many_chars_parser. It needs the negated charset to be defined though

iex(13)> parse_string(many_not_chars_parser("xy"), "aby")
{:ok, "ab"}

iex(14)> parser = many_not_chars_parser("xy")
...(14)> parse_string(parser, "ab\\ycx")
{:ok, "abyc"}

@spec maybe_escaped_char_parser(binary(), binary(), boolean(), binary?()) ::
  Minipeg.Parser.t()

Parses any character but delimiter, unless it is escpaed by escape_char or doubled in case allow_doubles is true.

@spec not_char_parser(char_set_t(), binary?()) :: Minipeg.Parser.t()

Parses any char with the exception of chars in the forbidden set

@spec prefixed_parser(char_set_t(), Minipeg.Parser.t(), binary?()) ::
  Minipeg.Parser.t()

parses only if parser parses a string with a prefix that is discarded

@spec rgx_capture_parser(binary(), binary?(), atoms()) :: Minipeg.Parser.t()

See Minipeg.Parsers.RgxParsers.rgx_capture_parser/3.

@spec rgx_match_parser(binary(), binary?(), atoms()) :: Minipeg.Parser.t()

See Minipeg.Parsers.RgxParsers.rgx_match_parser/3.

@spec rgx_parser(binary(), binary?(), atoms()) :: Minipeg.Parser.t()

See Minipeg.Parsers.RgxParsers.rgx_parser/3.

@spec string_parser(char_set_t(), binary?(), boolean(), binary?()) ::
  Minipeg.Parser.t()

A classic string parser which parses input like

• ""
• '"a\\'b"c'
• "ab""c"

but not

• 'ab
• "abc'
• "ad"e (e not parsed)

@spec success_parser(ast_t(), binary?()) :: Minipeg.Parser.t()

This parser always succeeds. N.B. It does not advance the input

@spec unsigned_int_parser(binary?()) :: Minipeg.Parser.t()

See Minipeg.Parsers.CommonParsers.unsigned_int_parser/1.

@spec upto_parser(char_set_t(), non_neg_integer(), binary?()) :: Minipeg.Parser.t()

parses a string up to the first char in charset fails iff less then min_count chars are parsed. If a character from charset is encountered it is removed from the input stream, but is not returned in the ast.

@spec ws_parser(boolean(), non_neg_integer(), binary?()) :: Minipeg.Parser.t()

Parses a sequence of at least min_count whitespaces. min_count defaults to 0