All Classes and Interfaces

Class	Description
Absent<T>	An Optional value that's never present.
AllOf<T>	A Predicate which is satisfied if all of a given number of predicates are satisfied.
AnyOf<T>	A Predicate which is satisfied if any of a given number of predicates are satisfied.
Anything<T>	A trivial Predicate which matches anything.
Ascending<T extends Comparable<? super T>>	An Iterable decorator which returns the elements of the delegate in their natural ascending order.
Ascii	A CharSequence adapter to ASCII encoded byte arrays.
Backed<T>	Single and Optional that delegates to the given Optional if that is present, otherwise falls back to the provided back-up Single.
BaseIterator<E>	The abstract super class of all Iterators in this package.
Batch<T>	A Procedure, which processes the elements of an Iterable using another Procedure.
BiFunction<Argument1,Argument2,Result>	A binary function.
BiProcedure<Argument1,Argument2>	Functional interface for a void function taking two arguments.
Broken<T,E extends Exception>	A Fragile which is broken and always throws an Exception.
By<Left,Right>	A BiFunction which compares two instances of different types by mapping them onto a common type and using a Comparator to compare those results.
By<T>	A Comparator which compares objects by a key derived from the compared objects.
Chunked<T>	An Iterable decorator which returns the elements of the decorated Iterable in chunks of a specific size.
Chunked<T>	In Iterator decorator which returns the elements of the decorated Iterator in chunks of a specific size.
Clamping<T extends Comparable<T>>	Function decorator that 'clamps' the value between the provided min and max values.
Clustered<T>	An Iterable decorator which clusters consecutive elements of another Iterable by the result of a Comparator.
Clustered<T>	An Iterator decorator which clusters consecutive elements of another Iterator by the result of a Comparator.
Collapsed<T>	Collapses the given Optional of Optional into Optional.
Collected<Value,Collection extends Collection<Value>>	A Single holding the collected values of an Iterable.
Composite<T>	A Comparator which delegates the comparison of two instances to other Comparators until the first one returns a non-zero result.
Composite<T>	A Procedure composed of other procedures.
Concat<E>	An Iterator that concatenates the results of other Iterators.
Conditional<T>	Optional that is present with the value of the provided target if it satisfies the given Predicate, otherwise it is absent.
Conditional<T>	A Procedure which only executes if the argument satisfies a Predicate.
DelegatingBiFunction<Left,Right,Result>	An abstract BiFunction which delegates to another given BiFunction.
DelegatingBiProcedure<Argument1,Argument2>	An abstract BiProcedure which delegates to another BiProcedure.
DelegatingCharSequence	CharSequence that delegates all calls to another CharSequence.
DelegatingComparator<T>	An abstract Comparator which delegates to another Comparator.
DelegatingFragile<T,E extends Exception>	An abstract Fragile which delegates all calls to another Fragile.
DelegatingFunction<Argument,Result>	An abstract Function which delegates to another Function.
DelegatingGeneratable<T>	An abstract Generatable which delegates to another Generatable.
DelegatingGenerator<Type>	An abstract Generator which delegates to another Generator.
DelegatingIterable<E>	An abstract Iterable which delegates all method calls to another given Iterable.
DelegatingIterator<E>	An abstract Iterator which delegates all method calls to another given Iterator.
DelegatingOptional<T>	An abstract Optional which delegates all method calls to another given Optional.
DelegatingPair<L,R>	An abstract Pair which delegates to another Pair.
DelegatingPredicate<T>	A Predicate which just delegates to another Predicate.
DelegatingProcedure<Argument>	An abstract Procedure which delegates to another Procedure.
DelegatingSingle<T>	A Single which delegates all calls to another Single.
Descending<T extends Comparable<? super T>>	An Iterable decorator which returns the elements of the delegate in their natural descending order.
Diff<Left,Right>	An Iterable of the differences of two given Iterables.
Diff<Left,Right>	An Iterator returning the differences of two given (sorted) Iterators.
DiffMap<Left,Right,Result>	A Function to be used to map the result of Diff using three delegate functions.
Digest	A Single of a byte array which represents the digested value of the given input data.
DigestGenerator	A Generator for MessageDigest instances of a specific digest algorithm.
Distinct<T>	An Iterator which drops duplicates of already iterated elements.
Distinct<T>	An Iterator which drops duplicates of already iterated elements.
EmptyIterable<E>	An Iterable that is always empty.
EmptyIterator<E>	An Iterator that is always empty.
EmptyStack<Element>	A Stack without any elements.
Equals<T>	A trivial Predicate which delegates to Object.equals(Object) and matches if it returns true.
Expanded<T>	A decorator for Iterable which expands each element into an Iterable (using the given function) and joins the results.
First<T>	An Iterable decorator which returns only the first few elements of the delegate.
First<T>	An Iterator which returns the first few elements of a delegate Iterator or Generator.
First<T>	The first value of an Iterable.
FirstPresent<T>	The first present value of an Iterable of Optionals.
ForEach<T>	The Object Oriented version of a for-each loop.
Fragile<T,E extends Exception>	A 1-tuple that may throw an Exception during retrieval of the value.
FragileBiFunction<Argument1,Argument2,Result,E extends Exception>	A binary function that can throw a checked Exception.
FragileBiProcedure<Argument1,Argument2,E extends Exception>	Functional interface for a void function taking two arguments that can throw a checked Exception.
FragileFunction<Argument,Result,E extends Exception>	A unary function that can throw a checked Exception.
FragileProcedure<Argument,Error extends Exception>	Functional interface for a void function taking one argument that can throw a checked Exception.
Frozen<T>	An Iterable stores the elements of the given Iterator or Iterable in order to allow re-iterating them.
Frozen<T>	An Optional decorator which avoids frequent (potentially expensive) evaluation of another Optional by retaining the result of the first evaluation.
Frozen<T>	Single decorator that queries the delegate only once and returns the same value instance ever after.
Function<Argument,Value>	A unary function.
Generatable<T>	A Generatable can return a Generator.
Generator<T>	A Generator is able to generate an infinite sequence of values.
GreaterAbsent<V>	A Comparator for Optional values.
Grouped	A CharSequence decorator which divides the delegate into groups of a specific size and inserts a separator char between them.
Having<Original,Derived>	A Predicate which delegates the test to another Predicate testing a value derived from the original testee.
Hex	The hexadecimal CharSequence representation of a byte array.
Hex	The Single of a hexadecimal representation of a Single array of bytes.
IdentityFunction<Argument>	Identity function.
In<T extends Comparable<T>>	A Predicate which is satisfied by Comparable elements within a specific closed interval.
Infinite<T>	A Generatable to Iterable adapter which continues iterating forever.
Infinite<T>	An Generator to Iterator adapter which iterates infinitely.
IterableComparator<T>	Comparator for Iterables.
Joined<T>	An Iterable which joins other Iterables by iterating the values of them one after another.
Joined<E>	An Iterator that serializes the values of multiple Iterables.
Just<T>	An Iterable which iterates a single value.
Just<T>	A present Optional that takes a Single for the value.
Just<T>	The most simple Single there is.
LazyDelegatingOptional<T>	An abstract Optional which delegates all method calls to another given Optional.
LeftSidedPair<Left,Right>	A Pair with an absent right element.
LeftWith<Left>	A Predicate to match the left value of a Pair.
LeftZipped<Left,Right,Result>	/** An Iterable combining the elements of two given Iterables using a BiFunction.
MapCollapsed<From,To>	Optional decorator maps the given Optional to an Optional and collapses the result.
MapEntry<V>	An Optional element of a Map.
Mapped<From,To,E extends Exception>	A Fragile decorator which maps the value using a given FragileFunction.
Mapped<OriginalType,ResultType>	Iterable decorator maps the results of the delegate Iterable using a given Function.
Mapped<OriginalType,ResultType>	An Iterator that maps the elements of another Iterator using a Function before iterating them.
Mapped<From,To>	Optional that maps an Optional if it's present using the given Function.
Md5	An MD5 MessageDigest Generator.
Next<E>	The next value of an Iterator.
NextPresent<T>	The next present value in the given Iterator of Optionals.
NoneOf<T>	A Predicate which matches if none of another sequence of predicates matches.
NonNull<T,E extends Exception>	A Fragile that fails when the given value was null.
Not<T>	A Predicate which inverts another Predicate.
Nothing<T>	A trivial Predicate which never matches.
NullSafe<T>	An Optional that's not present if the given value is null.
Numbered<T>	An Iterable decorator which pairs every value of another iterator with it's sequential ordinal number.
Optional<T>	An optional value.
OptionalComparator<V>	A Comparator for Optional values.
OuterZipped<Left,Right,Result>	/** An Iterable combining the elements of two given Iterables using a BiFunction.
Pair<Left,Right>	A pair of typed values, a tuple of two (also called ordered pair).
Paired<Left,Right>	An Iterable combining the elements of two given Iterables into an Iterable of Pairs.
Paired<Left,Right>	An Iterator combining the elements of two given Iterators into an Iterator of Pairs.
PairingFunction<Left,Right>	A BiFunction that creates a Pair from the two arguments.
PairWith<Left,Right>	A Predicate to match left and right value of a Pair.
Predicate<T>	A special function which returns true whenever the argument matches this predicate.
Present<T>	A special Optional that's always present.
PresentValues<T>	Iterable which iterates over the present values in the input Iterable of Optionals.
PresentValues<E>	Iterator that iterates over the present values from the input Iterator of Optionals of E.
Procedure<T>	Functional interface for a void function taking one argument.
Reduced<Value,Result>	The Single value of a reduced Iterable.
Restrained<T>	Optional decorator restrains the presence of another Optional with a specific (independent) condition.
Reverse<T>	A Comparator which reverses the order of another Comparator.
Reverse<T>	Iterable decorator that iterates the values of another Iterable in reverse order.
RightSidedPair<Left,Right>	A Pair with an absent left element.
RightWith<Right>	A Predicate to match the right value of a Pair.
RightZipped<Left,Right,Result>	/** An Iterable combining the elements of two given Iterables using a BiFunction.
SameAs<T>	A trivial Predicate which compares the instances of two objects and matches if they are the same.
Seq<T>	Iterable sequence of values.
Seq<E>	An Iterator of a sequence of values.
Sequence<T>	A sequence Generatable.
Sequence<T>	A sequence Generator.
Sha256	A SHA-256 MessageDigest Generator.
Sieved<E>	Iterable decorator which iterates all elements of the delegate which satisfy a given Predicate.
Sieved<E>	Iterator decorator which iterates all elements of the delegate which satisfy a given Predicate.
Sieved<T>	Optional decorator which is present if the delegate is present and satisfies a specific Predicate.
Single<T>	A 1-tuple.
SingleFunction<T>	A Function which produces Singles of its arguments.
SingleIterator<E>	An Iterator to iterate the sole value of a Single.
SingleStack<Element>	A Stack of a single element.
SingletonIterable<E>	Iterable with a single element.
SingletonIterator<E>	An iterator to iterate a single value.
SingleWith<V>	A Predicate to match the value of a Single.
Sorted<T>	An Iterable decorator which returns the elements of the delegate in a sorted order, determined by a given Comparator.
Stack<Element>	An immutable stack.
Stack.StackTop<Element>	The top of a Stack.
StackIterable<Element>	An Iterable which iterates the elements of a Stack.
StackIterator<Element>	An Iterator iterating the elements of a Stack.
ThrowingFunction<Argument,Result>	A unary function that can throw a Throwable.
Topped<Element>	A Stack based on another Stack and a new top element.
Unchecked<Argument,Result,E extends Throwable>	A FragileFunction to Function adapter which wraps any Exception into a RuntimeException.
Unchecked<T,E extends Exception>	A Fragile to Single adapter which throws an unchecked Exception if the fragile delegate is broken.
ValuePair<Left,Right>	The most simple Pair there is.
Zipped<Result,E extends Exception>	A Fragile which combines two other Fragiles with a FragileBiFunction.
Zipped<Result>	An Iterable combining the elements of two given Iterables using a BiFunction.
Zipped<Left,Right,Result>	An Iterator combining the elements of two given Iterators using a BiFunction.
Zipped<Left,Right,Result>	An Optional which combines two other Optionals with a BiFunction if they are both present and is absent otherwise.