View Source Minipeg.Parsers.BasicParsers (Minipeg v0.7.5)

Basic parsers which would be sufficient to write any parser but are of course completed by many more convenience parsers

Summary

Functions

Parser that only succeeds on empty input / end of input

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

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

Types

ast_list_t()

@type ast_list_t() :: [ast_t()]

ast_t()

@type ast_t() :: any()

atoms()

@type atoms() :: [atom()]

binaries()

@type binaries() :: [binary()]

binary?()

@type binary?() :: maybe(binary())

char_set_spec_t()

@type char_set_spec_t() :: maybe(binary() | list())

char_set_t()

@type char_set_t() :: [binary()] | binary()

either(success_t, error_t)

@type either(success_t, error_t) :: {:ok, success_t} | {:error, error_t}

input_t()

@type input_t() :: binary() | [binary()] | Minipeg.Input.t()

maybe(t)

@type maybe(t) :: nil | t

name_t()

@type name_t() :: atom() | binary()

name_t?()

@type name_t?() :: maybe(name_t())

parser_function_t()

@type parser_function_t() :: (Minipeg.Input.t(), Minipeg.Cache.t(), binary() ->
                          result_t())

position_t()

@type position_t() :: {pos_integer(), pos_integer()}

result_t()

@type result_t() :: Minipeg.Failure.t() | Minipeg.Ignore.t() | Minipeg.Success.t()

satisfier_result_t()

@type satisfier_result_t() :: either(any(), binary())

satisfier_t()

@type satisfier_t() :: (any() -> satisfier_result_t())

str_or_count_t()

@type str_or_count_t() :: binary() | non_neg_integer()

token1_comp_t()

@type token1_comp_t() ::
  {atom(), token_parse_part2()}
  | {atom(), token_parse_part2(), (binary() -> any())}

token1_spec_t()

@type token1_spec_t() ::
  {atom(), token_parse_part1()}
  | {atom(), token_parse_part1(), (binary() -> any())}

token_comp_t()

@type token_comp_t() :: [token1_comp_t()]

token_spec_t()

@type token_spec_t() :: [token1_spec_t()]

Functions

char_parser(specified_set \\ nil, name \\ nil)

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

end_parser(name \\ nil)

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

Parser that only succeeds on empty input / end of input

failure_parser(reason \\ nil, name \\ nil)

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

not_char_parser(forbidden, name)

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

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

success_parser(return_ast \\ nil, name \\ nil)

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

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