Minipeg.Combinators (Minipeg v0.7.6)
View SourceAll public functions in this module take a parser and potentially more parameters and return a new parser
Summary
Functions
Just parses with parser
but displays, input and result to stderr
ALternatively, if a function is provided the function is called and
nothing is printed to stderr
This parser, iff it succeeds returns a special Ignore
result that is ignored inside a sequence
combinator
Parsers a string that would be parsed by parser but ignoring leading whitespace, if you also want to
ignore whitespace after the parsed string use tokenized
Unwrapps a wrapped parser and parses with it. This is used for recursive rules, e.g.
Parses a list defined by an element_parser
and a seperator_parser
Applies a parser as many times as possible, can use min_count
(defaulting to 0) to
fail unless the parser could parse min_count
times
many_sel([...])
is just a convenience for many(select([...]))
many_seq([...])
is just a convenience for many(sequence([...]))
Succeeds if parser
succeeds, but maps the ast with mapper_fun
.
If parser
fails, it fails
If parser
fails, it fails with the error mapped by error_fun
If parser
succeeds, it just passes the result along
parses iff parser
parses then maps the ast to a string with IO.chardata_to_string/1
The ast must therefore be of type IO data
Like map
, but this also provides a second argument, the position in form of a tuple {col, lnb}
to the mapper function
Returns a parser that only succeeds if the original parser succeeds and the satisfier function that is called with the ast of the original result returns {:ok, value}. It also changes the original ast with value in the final result.
Looks into the cache (for this parsing position) before parsing, if no result found parses and puts the result into the cache (for this parsing position)
succeeds with the first parser that succeeds in parsers
, otherwise fails
Consume chars until parser
parses and return them as parsed ast, fails if parser never succeeds
can add the delimiter to the ast or leave it on the input stream
A shortcut for mapp(parser, &{&1, &2}...
Types
@type ast_list_t() :: [ast_t()]
@type ast_t() :: any()
@type atoms() :: [atom()]
@type binaries() :: [binary()]
@type either(success_t, error_t) :: {:ok, success_t} | {:error, error_t}
@type input_t() :: binary() | [binary()] | Minipeg.Input.t()
@type maybe(t) :: nil | t
@type parser_function_t() :: (Minipeg.Input.t(), Minipeg.Cache.t(), binary() -> result_t())
@type position_t() :: {pos_integer(), pos_integer()}
@type result_t() :: Minipeg.Failure.t() | Minipeg.Ignore.t() | Minipeg.Success.t()
@type satisfier_t() :: (any() -> satisfier_result_t())
@type str_or_count_t() :: binary() | non_neg_integer()
@type token_comp_t() :: [token1_comp_t()]
@type token_spec_t() :: [token1_spec_t()]
@type wrapped_parser_t() :: (-> Minipeg.Parser.t())
Functions
@spec debug( Minipeg.Parser.t(), binary?(), maybe((Minipeg.Input.t(), result_t() -> any())) ) :: Minipeg.Parser.t()
Just parses with parser
but displays, input and result to stderr
ALternatively, if a function is provided the function is called and
nothing is printed to stderr
@spec ignore(Minipeg.Parser.t(), maybe(binary())) :: Minipeg.Parser.t()
This parser, iff it succeeds returns a special Ignore
result that is ignored inside a sequence
combinator
@spec ignore_ws(Minipeg.Parser.t(), binary?(), boolean()) :: Minipeg.Parser.t()
Parsers a string that would be parsed by parser but ignoring leading whitespace, if you also want to
ignore whitespace after the parsed string use tokenized
@spec in_between_parser( Minipeg.Parser.t(), Minipeg.Parser.t(), Minipeg.Parser.t(), binary?() ) :: Minipeg.Parser.t()
@spec lazy(wrapped_parser_t(), binary?()) :: Minipeg.Parser.t()
Unwrapps a wrapped parser and parses with it. This is used for recursive rules, e.g.
```elixir
def my_parser...
sequence([...
lazy(fn -> my_parser() end)
```
@spec list_parser( Minipeg.Parser.t(), Minipeg.Parser.t(), binary?(), non_neg_integer() ) :: Minipeg.Parser.t()
Parses a list defined by an element_parser
and a seperator_parser
@spec many(Minipeg.Parser.t(), maybe(binary()), non_neg_integer()) :: Minipeg.Parser.t()
Applies a parser as many times as possible, can use min_count
(defaulting to 0) to
fail unless the parser could parse min_count
times
@spec many_as_string(Minipeg.Parser.t(), maybe(binary()), non_neg_integer()) :: Minipeg.Parser.t()
@spec many_sel([Minipeg.Parser.t()], binary?(), non_neg_integer()) :: Minipeg.Parser.t()
many_sel([...])
is just a convenience for many(select([...]))
@spec many_seq([Minipeg.Parser.t()], binary?(), non_neg_integer()) :: Minipeg.Parser.t()
many_seq([...])
is just a convenience for many(sequence([...]))
@spec map(Minipeg.Parser.t(), (ast_t() -> ast_t()), maybe(binary())) :: Minipeg.Parser.t()
Succeeds if parser
succeeds, but maps the ast with mapper_fun
.
If parser
fails, it fails
@spec map_error( Minipeg.Parser.t(), (Minipeg.Failure.t() -> Minipeg.Failure.t()), binary?() ) :: Minipeg.Parser.t()
If parser
fails, it fails with the error mapped by error_fun
If parser
succeeds, it just passes the result along
@spec map_to_string(Minipeg.Parser.t(), binary?()) :: Minipeg.Parser.t()
parses iff parser
parses then maps the ast to a string with IO.chardata_to_string/1
The ast must therefore be of type IO data
@spec mapp(Minipeg.Parser.t(), (ast_t(), position_t() -> ast_t()), maybe(binary())) :: Minipeg.Parser.t()
Like map
, but this also provides a second argument, the position in form of a tuple {col, lnb}
to the mapper function
@spec maybe(Minipeg.Parser.t(), binary?()) :: Minipeg.Parser.t()
@spec maybe_as_empty(Minipeg.Parser.t(), binary?()) :: Minipeg.Parser.t()
@spec option([Minipeg.Parser.t()], binary?()) :: Minipeg.Parser.t()
@spec satisfy(Minipeg.Parser.t(), satisfier_t(), binary?()) :: Minipeg.Parser.t()
Returns a parser that only succeeds if the original parser succeeds and the satisfier function that is called with the ast of the original result returns {:ok, value}. It also changes the original ast with value in the final result.
@spec savepoint(Minipeg.Parser.t(), binary?(), binary?()) :: Minipeg.Parser.t()
Looks into the cache (for this parsing position) before parsing, if no result found parses and puts the result into the cache (for this parsing position)
@spec select([Minipeg.Parser.t()], binary?()) :: Minipeg.Parser.t()
succeeds with the first parser that succeeds in parsers
, otherwise fails
@spec sequence([Minipeg.Parser.t()], binary?()) :: Minipeg.Parser.t()
@spec set_error(Minipeg.Parser.t(), binary?(), binary?()) :: Minipeg.Parser.t()
@spec tokenize(Minipeg.Parser.t()) :: Minipeg.Parser.t()
@spec upto_parser_parser(Minipeg.Parser.t(), binary?(), upto_behavior_t()) :: Minipeg.Parser.t()
Consume chars until parser
parses and return them as parsed ast, fails if parser never succeeds
can add the delimiter to the ast or leave it on the input stream
@spec with_pos(Minipeg.Parser.t(), binary?()) :: Minipeg.Parser.t()
A shortcut for mapp(parser, &{&1, &2}...