Package de.scravy.bedrock

Interface Parser<T>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Parser<T>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	Parser.Result<E>

Method Summary

Modifier and Type	Method	Description
static <S, T extends S, U extends S> Parser<S>	choice(Parser<T> p1, Parser<U> p2)
static <T, U> Parser<Either<T,U>>	either(Parser<T> p1, Parser<U> p2)
static <T, U> Parser<T>	left(Parser<T> p1, Parser<U> p2)	Creates a parser that parses p1 and then p2 but returns the result of p1 (the left one).
static <T> Parser<Seq<T>>	many(Parser<T> parser)
static <T> Parser<Seq<T>>	many1(Parser<T> parser)
default <U> Parser<U>	map(Function<T,U> f)
static <T> Parser<T>	oneOf(Parser<? extends T>... ps)
static <T> Parser<T>	option(Supplier<T> fallbackSupplier, Parser<T> parser)
static <T> Parser<T>	option(T fallback, Parser<T> parser)
static <T> Parser<Optional<T>>	optional(Parser<T> parser)
Parser.Result<T>	parse(Seq<?> seq)
static <T, U> Parser<U>	recurse(Class<T> clazz, Predicate<T> predicate, Function<T,Seq<?>> extractor, Parser<U> parser)
static <T, U> Parser<U>	recurse2(Class<T> clazz, Function<T,Seq<?>> extractor, Function<T,Parser<U>> parser)
static <T> Parser<T>	recursive(Supplier<Parser<T>> supplier)	Creates a parser that is constructed at first invocation for recursive invocation of the parser.
static <T, U> Parser<U>	right(Parser<T> p1, Parser<U> p2)	Creates a parser that parses p1 and then p2 but returns the result of p2 (the right one).
static <T> Parser<T>	satisfies(Class<T> clazz, Predicate<T> predicate)
static <T, U> Parser<U>	satisfies2(Class<T> clazz, Function<T,Optional<U>> f)
static <T, U> Parser<Seq<T>>	sepBy(Parser<T> parser, Parser<U> sep)
static <T, U> Parser<Seq<T>>	sepBy1(Parser<T> parser, Parser<U> sep)
static <T, U> Parser<Pair<T,U>>	seq(Parser<T> p1, Parser<U> p2)
static <T, U, V> Parser<Triple<T,U,V>>	seq(Parser<T> p1, Parser<U> p2, Parser<V> p3)
static <T, U, V, W> Parser<Quadruple<T,U,V,W>>	seq(Parser<T> p1, Parser<U> p2, Parser<V> p3, Parser<W> p4)
static <T> Parser<Seq<T>>	sequence(Parser<T>... ps)
static <T> Parser<Seq<T>>	sequence(Iterable<Parser<T>> ps)
static <T> boolean	shuntingYard(Iterable<T> in, Consumer<T> out, Mapping<T,Integer> precedenceMap, Predicate<T> isLeftAssociative, Predicate<T> isLeftBracket, Predicate<T> isRightBracket)
static <T> boolean	shuntingYard(Iterable<T> in, Consumer<T> out, Predicate<T> isOperator, BiPredicate<T,T> hasHigherPrecedenceThan, BiPredicate<T,T> hasEqualPrecedenceAs, Predicate<T> isLeftAssociative, Predicate<T> isLeftBracket, Predicate<T> isRightBracket)
static <T> Parser<Void>	skipMany(Parser<T> parser)
static <T> Parser<Seq<T>>	times(int n, Parser<T> p)

Method Details

parse

Parser.Result<T> parse(Seq<?> seq)

map

default <U> Parser<U> map(Function<T,U> f)

left

static <T, U> Parser<T> left(Parser<T> p1, Parser<U> p2)

Creates a parser that parses p1 and then p2 but returns the result of p1 (the left one).

Type Parameters:

T - The type parsed by the left parser.

U - The type parsed by the right parser.

Parameters:

p1 - The left parser.

p2 - The right parser.

Returns:

A parser that parses p1 and then p2 but returns the result of p1 (the left one).

right

static <T, U> Parser<U> right(Parser<T> p1, Parser<U> p2)

Creates a parser that parses p1 and then p2 but returns the result of p2 (the right one).

Type Parameters:

T - The type parsed by the left parser.

U - The type parsed by the right parser.

Parameters:

p1 - The left parser.

p2 - The right parser.

Returns:

A parser that parses p1 and then p2 but returns the result of p2 (the right one).

choice

static <S, T extends S, U extends S> Parser<S> choice(Parser<T> p1, Parser<U> p2)

either

static <T, U> Parser<Either<T,U>> either(Parser<T> p1, Parser<U> p2)

oneOf

@SafeVarargs static <T> Parser<T> oneOf(Parser<? extends T>... ps)

satisfies

static <T> Parser<T> satisfies(Class<T> clazz, Predicate<T> predicate)

satisfies2

static <T, U> Parser<U> satisfies2(Class<T> clazz, Function<T,Optional<U>> f)

recurse

static <T, U> Parser<U> recurse(Class<T> clazz, Predicate<T> predicate, Function<T,Seq<?>> extractor, Parser<U> parser)

recurse2

static <T, U> Parser<U> recurse2(Class<T> clazz, Function<T,Seq<?>> extractor, Function<T,Parser<U>> parser)

optional

static <T> Parser<Optional<T>> optional(Parser<T> parser)

option

static <T> Parser<T> option(T fallback, Parser<T> parser)

option

static <T> Parser<T> option(Supplier<T> fallbackSupplier, Parser<T> parser)

sequence

@SafeVarargs static <T> Parser<Seq<T>> sequence(Parser<T>... ps)

sequence

static <T> Parser<Seq<T>> sequence(Iterable<Parser<T>> ps)

times

static <T> Parser<Seq<T>> times(int n, Parser<T> p)

seq

static <T, U> Parser<Pair<T,U>> seq(Parser<T> p1, Parser<U> p2)

seq

static <T, U, V> Parser<Triple<T,U,V>> seq(Parser<T> p1, Parser<U> p2, Parser<V> p3)

seq

static <T, U, V, W> Parser<Quadruple<T,U,V,W>> seq(Parser<T> p1, Parser<U> p2, Parser<V> p3, Parser<W> p4)

many

static <T> Parser<Seq<T>> many(Parser<T> parser)

many1

static <T> Parser<Seq<T>> many1(Parser<T> parser)

skipMany

static <T> Parser<Void> skipMany(Parser<T> parser)

sepBy

static <T, U> Parser<Seq<T>> sepBy(Parser<T> parser, Parser<U> sep)

sepBy1

static <T, U> Parser<Seq<T>> sepBy1(Parser<T> parser, Parser<U> sep)

recursive

static <T> Parser<T> recursive(Supplier<Parser<T>> supplier)

Creates a parser that is constructed at first invocation for recursive invocation of the parser.

shuntingYard

static <T> boolean shuntingYard(Iterable<T> in, Consumer<T> out, Mapping<T,Integer> precedenceMap, Predicate<T> isLeftAssociative, Predicate<T> isLeftBracket, Predicate<T> isRightBracket)

shuntingYard

static <T> boolean shuntingYard(Iterable<T> in, Consumer<T> out, Predicate<T> isOperator, BiPredicate<T,T> hasHigherPrecedenceThan, BiPredicate<T,T> hasEqualPrecedenceAs, Predicate<T> isLeftAssociative, Predicate<T> isLeftBracket, Predicate<T> isRightBracket)