Parser (org.typemeta:funcj-parser 0.6.15 API)

Type Parameters:

I - the input stream symbol type

A - the parser result type

All Known Implementing Classes:

Ref
```
public interface Parser<I,A>
```
A parser is essentially a function from an input stream to a parse Result. The Parser type along with the pure and ap functions constitute an applicative functor.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`Lazy<Boolean>`	`acceptsEmpty()` Indicate whether this parser accepts the empty symbol.
`default <B> ApplyBuilder._2<I,A,B>`	`and(Parser<I,B> pb)` Combine this parser with another to form a builder which accumulates the parse results.
`default <B> Parser<I,A>`	`andL(Parser<I,B> pb)` Combine this parser with another to form a parser which applies two parsers, and if they are both successful throws away the result of the right-hand parser, and returns the result of the left-hand parser
`default <B> Parser<I,B>`	`andR(Parser<I,B> pb)` Combine this parser with another to form a parser which applies two parsers, and if they are both successful throws away the result of the left-hand parser and returns the result of the right-hand parser
`static <I,A,B> Parser<I,B>`	`ap(Functions.F<A,B> f, Parser<I,A> pa)` Construct a parser that, if `pa` succeeds, yielding a function `a`, then it returns the result of applying function `f` to value `a`.
`static <I,A,B> Parser<I,B>`	`ap(Parser<I,Functions.F<A,B>> pf, Parser<I,A> pa)` Construct a parser that, if `pf` succeeds, yielding a function `f`, and if `pa` succeeds, yielding a value `a`, then it returns the result of applying function `f` to value `a`.
`default Result<I,A>`	`apply(Input<I> in)` Apply this parser to the input stream.
`Result<I,A>`	`apply(Input<I> in, SymSet<I> follow)` Apply this parser to the input stream.
`default <OPEN,CLOSE> Parser<I,A>`	`between(Parser<I,OPEN> open, Parser<I,CLOSE> close)` A parser for expressions with enclosing symbols.
`default <B> Parser<I,B>`	`cast()`
`default Parser<I,A>`	`chainl(Parser<I,Functions.Op2<A>> op, A a)` A parser for an operand, followed by zero or more operands that are separated by operators.
`default Parser<I,A>`	`chainl1(Parser<I,Functions.Op2<A>> op)` A parser for an operand, followed by one or more operands that are separated by operators.
`default Parser<I,A>`	`chainr(Parser<I,Functions.Op2<A>> op, A a)` A parser for an operand, followed by zero or more operands that are separated by operators.
`default Parser<I,A>`	`chainr1(Parser<I,Functions.Op2<A>> op)` A parser for an operand, followed by one or more operands that are separated by operators.
`static <I,A> Parser<I,A>`	`choice(IList.NonEmpty<Parser<I,A>> ps)` A parser that attempts one or more parsers in turn and returns the result of the first that succeeds, or else fails.
`static <I,A> Parser<I,A>`	`choice(Parser<I,A>... ps)` A parser that attempts one or more parsers in turn and returns the result of the first that succeeds, or else fails.
`Lazy<SymSet<I>>`	`firstSet()` The First Set for this parser.
`default Parser<I,IList<A>>`	`many()` A parser which repeatedly applies this parser until it fails, and then returns an `IList` of the results.
`default Parser<I,IList.NonEmpty<A>>`	`many1()` A parser which applies this parser one or more times until it fails, and then returns an `IList` of the results.
`default <B> Parser<I,IList<A>>`	`manyTill(Parser<I,B> end)` A parser which repeatedly applies this parser until the end parser succeeds, and then returns an `IList` of the results.
`default <B> Parser<I,B>`	`map(Functions.F<A,B> f)` Construct a parser that, if this parser succeeds then returns the result of applying the function `f` to the result, otherwise return the failure.
`default Parser<I,Optional<A>>`	`optional()` A parser that applies this parser, and, if it succeeds, returns the result wrapped in an `Optional`, otherwise returns an empty `Optional`.
`default <B extends A> Parser<I,A>`	`or(Parser<I,B> rhs)` Construct a parser which returns the result of either this parser or, if it fails, then the result of the `rhs` parser.
`default Result<I,A>`	`parse(Input<I> in)` Apply this parser to the input stream.
`static <I,A> Parser<I,A>`	`pure(A a)` Applicative unit/pure function.
`static <I,A> Ref<I,A>`	`ref()` Construct an uninitialised parser reference object.
`static <I,A> Ref<I,A>`	`ref(Parser<I,A> p)` Construct a parser reference object from a parser.
`default <SEP> Parser<I,IList<A>>`	`sepBy(Parser<I,SEP> sep)` A parser which applies this parser zero or more times until it fails, alternating with calls to the `sep` parser.
`default <SEP> Parser<I,IList<A>>`	`sepBy1(Parser<I,SEP> sep)` A parser which applies this parser one or more times until it fails, alternating with calls to the `sep` parser.
`static <I,T> Parser<I,IList<T>>`	`sequence(IList<Parser<I,T>> lpt)` Standard applicative sequencing.
`static <E,T> Parser<E,Stream<T>>`	`sequence(Stream<Parser<E,T>> spt)` Variation of `sequence(IList)` for `Stream`.
`default Parser<I,Unit>`	`skipMany()` A parser which applies this parser zero or more times until it fails, and throws away the results.
`static <I,T,U> Parser<I,IList<U>>`	`traverse(IList<T> lt, Functions.F<T,Parser<I,U>> f)` Standard applicative traversal.

- Method Detail
 - ref
```
static <I,A> Ref<I,A> ref()
```
 Construct an uninitialised parser reference object.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the parser result type
 
 Returns:
 
 the uninitialised parser reference
 - ref
```
static <I,A> Ref<I,A> ref(Parser<I,A> p)
```
 Construct a parser reference object from a parser.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the parser result type
 
 Parameters:
 
 p - the parser
 
 Returns:
 
 the initialised parser reference
 - pure
```
static <I,A> Parser<I,A> pure(A a)
```
 Applicative unit/pure function. Construct a parser that always returns the given value, without consuming any input.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the parser result type
 
 Parameters:
 
 a - the value
 
 Returns:
 
 a parser that always returns the given value
 - ap
```
static <I,A,B> Parser<I,B> ap(Parser<I,Functions.F<A,B>> pf,
 Parser<I,A> pa)
```
 Construct a parser that, if pf succeeds, yielding a function f, and if pa succeeds, yielding a value a, then it returns the result of applying function f to value a. Otherwise, if pf fails then the parser returns the failure, else if pa fails then it returns that failure.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the input type of the function
 
 B - the return type of the function
 
 Parameters:
 
 pf - the parser that returns a function result
 
 pa - the parser that returns a value result
 
 Returns:
 
 a parser that returns the result of applying the parsed function to the parsed value
 - ap
```
static <I,A,B> Parser<I,B> ap(Functions.F<A,B> f,
 Parser<I,A> pa)
```
 Construct a parser that, if pa succeeds, yielding a function a, then it returns the result of applying function f to value a. If pa fails then the parser returns the failure.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the input type of the function
 
 B - the return type of the function
 
 Parameters:
 
 f - the function
 
 pa - the parser that returns a value result
 
 Returns:
 
 a parser that returns the result of applying the function to the parsed value
 - traverse
```
static <I,T,U> Parser<I,IList> traverse(IList<T> lt,
 Functions.F<T,Parser<I,U>> f)
```
 Standard applicative traversal.
 Equivalent to
```
sequence(lt.map(f))
```
 .
 Type Parameters:
 
 I - the error type
 
 T - the type of list elements
 
 U - the type wrapped by the Try returned by the function
 
 Parameters:
 
 lt - the list of values
 
 f - the function to be applied to each value in the list
 
 Returns:
 
 a Parser which wraps an IList of values
 - sequence
```
static <I,T> Parser<I,IList<T>> sequence(IList<Parser<I,T>> lpt)
```
 Standard applicative sequencing.
 Translate a IList of Parser into a Parser of an IList, by composing each consecutive Parser using the ap(Parser, Parser) method.
 
 Type Parameters:
 
 I - the error type
 
 T - the value type of the Parsers in the list
 
 Parameters:
 
 lpt - the list of Parser values
 
 Returns:
 
 a Parser which wraps an IList of values
 - sequence
```
static <E,T> Parser<E,Stream<T>> sequence(Stream<Parser<E,T>> spt)
```
 Variation of sequence(IList) for Stream.
 
 Type Parameters:
 
 E - the error type
 
 T - the value type of the Parsers in the stream
 
 Parameters:
 
 spt - the stream of Parser values
 
 Returns:
 
 a Parser which wraps an Stream of values
 - parse
```
default Result<I,A> parse(Input in)
```
 Apply this parser to the input stream. Fail if eof isn't reached.
 
 Parameters:
 
 in - the input stream
 
 Returns:
 
 the parser result
 - acceptsEmpty
```
Lazy<Boolean> acceptsEmpty()
```
 Indicate whether this parser accepts the empty symbol.
 
 Returns:
 
 a lazy wrapper for true iff the parser accepts the empty symbol
 - firstSet
```
Lazy<SymSet> firstSet()
```
 The First Set for this parser.
 
 Returns:
 
 a lazy symbol set
 - apply
```
Result<I,A> apply(Input in,
 SymSet follow)
```
 Apply this parser to the input stream. Note: If this parser is being used as a standalone parser, then call parse(Input) to parse an input.
 
 Parameters:
 
 in - the input stream
 
 follow - the dynamic follow set
 
 Returns:
 
 the parse result
 - apply
```
default Result<I,A> apply(Input in)
```
 Apply this parser to the input stream. Note: If this parser is being used as a standalone parser, then call parse(Input) to parse an input.
 
 Parameters:
 
 in - the input stream
 
 Returns:
 
 the parser result
 - cast
```
default  Parser<I,B> cast()
```
 - map
```
default  Parser<I,B> map(Functions.F<A,B> f)
```
 Construct a parser that, if this parser succeeds then returns the result of applying the function f to the result, otherwise return the failure.
 
 Type Parameters:
 
 B - the function return type
 
 Parameters:
 
 f - the function to be mapped over this parser
 
 Returns:
 
 a parser that returns f mapped over this parser's result
 - or
```
default  Parser<I,A> or(Parser<I,B> rhs)
```
 Construct a parser which returns the result of either this parser or, if it fails, then the result of the rhs parser.
 
 Type Parameters:
 
 B - the rhs parser result type
 
 Parameters:
 
 rhs - the second parser to attempt
 
 Returns:
 
 a parser which returns the result of either this parser or the rhs parser.
 - and
```
default  ApplyBuilder._2<I,A,B> and(Parser<I,B> pb)
```
 Combine this parser with another to form a builder which accumulates the parse results.
 
 Type Parameters:
 
 B - the result type of second parser
 
 Parameters:
 
 pb - the second parser
 
 Returns:
 
 an ApplyBuilder which accumulates the parse results.
 - andL
```
default  Parser<I,A> andL(Parser<I,B> pb)
```
 Combine this parser with another to form a parser which applies two parsers, and if they are both successful throws away the result of the right-hand parser, and returns the result of the left-hand parser
 
 Type Parameters:
 
 B - the result type of second parser
 
 Parameters:
 
 pb - the second parser
 
 Returns:
 
 a parser that applies two parsers consecutively and returns the result of the first
 - andR
```
default  Parser<I,B> andR(Parser<I,B> pb)
```
 Combine this parser with another to form a parser which applies two parsers, and if they are both successful throws away the result of the left-hand parser and returns the result of the right-hand parser
 
 Type Parameters:
 
 B - the result type of second parser
 
 Parameters:
 
 pb - the second parser
 
 Returns:
 
 a parser that applies two parsers consecutively and returns the result of the second
 - many
```
default Parser<I,IList<A>> many()
```
 A parser which repeatedly applies this parser until it fails, and then returns an IList of the results. If this parser fails on the first attempt then the parser succeeds, with an empty list of results.
 
 Returns:
 
 a parser which applies this parser zero or more times until it fails
 - manyTill
```
default  Parser<I,IList<A>> manyTill(Parser<I,B> end)
```
 A parser which repeatedly applies this parser until the end parser succeeds, and then returns an IList of the results.
 
 Type Parameters:
 
 B - the result type of the end parser
 
 Parameters:
 
 end - the end parser
 
 Returns:
 
 a parser which applies this parser zero or more times until end succeeds
 - choice
```
static <I,A> Parser<I,A> choice(IList.NonEmpty<Parser<I,A>> ps)
```
 A parser that attempts one or more parsers in turn and returns the result of the first that succeeds, or else fails.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the parser result type
 
 Parameters:
 
 ps - the list of parsers
 
 Returns:
 
 a parser that attempts one or more parsers in turn
 - choice
```
@SafeVarargs
static <I,A> Parser<I,A> choice(Parser<I,A>... ps)
```
 A parser that attempts one or more parsers in turn and returns the result of the first that succeeds, or else fails.
 
 Type Parameters:
 
 I - the input stream symbol type
 
 A - the parser result type
 
 Parameters:
 
 ps - the list of parsers
 
 Returns:
 
 a parser that attempts one or more parsers in turn
 - many1
```
default Parser<I,IList.NonEmpty<A>> many1()
```
 A parser which applies this parser one or more times until it fails, and then returns an IList of the results. Note, if this parser fails on the first attempt then the parser fails.
 
 Returns:
 
 a parser which applies this parser repeatedly until it fails
 - skipMany
```
default Parser<I,Unit> skipMany()
```
 A parser which applies this parser zero or more times until it fails, and throws away the results. Note, if this parser fails on the first attempt then the parser succeeds.
 
 Returns:
 
 a parser which applies this parser repeatedly until it fails
 - sepBy
```
default <SEP> Parser<I,IList<A>> sepBy(Parser<I,SEP> sep)
```
 A parser which applies this parser zero or more times until it fails, alternating with calls to the sep parser. The results of this parser are collected in a IList and returned by the parser.
 
 Type Parameters:
 
 SEP - the separator type
 
 Parameters:
 
 sep - the separator parser
 
 Returns:
 
 a parser which applies this parser zero or more times alternated with sep
 - sepBy1
```
default <SEP> Parser<I,IList<A>> sepBy1(Parser<I,SEP> sep)
```
 A parser which applies this parser one or more times until it fails, alternating with calls to the sep parser. The results of this parser are collected in a IList and returned by the parser.
 
 Type Parameters:
 
 SEP - the separator type
 
 Parameters:
 
 sep - the separator parser
 
 Returns:
 
 a parser which applies this parser one or more times alternated with sep
 - optional
```
default Parser<I,Optional<A>> optional()
```
 A parser that applies this parser, and, if it succeeds, returns the result wrapped in an Optional, otherwise returns an empty Optional.
 
 Returns:
 
 an optional parser
 - between
```
default <OPEN,CLOSE> Parser<I,A> between(Parser<I,OPEN> open,
 Parser<I,CLOSE> close)
```
 A parser for expressions with enclosing symbols.
 A parser which applies the open parser, then this parser, and then close parser. If all three succeed then the result of this parser is returned.
 
 Type Parameters:
 
 OPEN - the open parser result type
 
 CLOSE - the close parser result type
 
 Parameters:
 
 open - the open symbol parser
 
 close - the close symbol parser
 
 Returns:
 
 a parser for expressions with enclosing symbols
 - chainr
```
default Parser<I,A> chainr(Parser<I,Functions.Op2<A>> op,
 A a)
```
 A parser for an operand, followed by zero or more operands that are separated by operators. The operators are right-associative.
 
 Parameters:
 
 op - the parser for the operator
 
 a - the value to return if there are no operands
 
 Returns:
 
 a parser for operator expressions
 - chainr1
```
default Parser<I,A> chainr1(Parser<I,Functions.Op2<A>> op)
```
 A parser for an operand, followed by one or more operands that are separated by operators. The operators are right-associative.
 
 Parameters:
 
 op - the parser for the operator
 
 Returns:
 
 a parser for operator expressions
 - chainl
```
default Parser<I,A> chainl(Parser<I,Functions.Op2<A>> op,
 A a)
```
 A parser for an operand, followed by zero or more operands that are separated by operators. The operators are left-associative. This can, for example, be used to eliminate left recursion which typically occurs in expression grammars.
 
 Parameters:
 
 op - the parser for the operator
 
 a - the value to return if there are no operands
 
 Returns:
 
 a parser for operator expressions
 - chainl1
```
default Parser<I,A> chainl1(Parser<I,Functions.Op2<A>> op)
```
 A parser for an operand, followed by one or more operands that are separated by operators. The operators are left-associative. This can, for example, be used to eliminate left recursion which typically occurs in expression grammars.
 
 Parameters:
 
 op - the parser for the operator
 
 Returns:
 
 a parser for operator expressions

Interface Parser<I,A>

Method Summary

Method Detail

ref

ref

pure

ap

ap

traverse

sequence

sequence

parse

acceptsEmpty

firstSet

apply

apply

cast

map

or

and

andL

andR

many

manyTill

choice

choice

many1

skipMany

sepBy

sepBy1

optional

between

chainr

chainr1

chainl

chainl1