de.caff.generics

## Class Types

- java.lang.Object
- - de.caff.generics.Types

-     public final class Types
      extends java.lang.Object

  Tool with helpful methods for type conversion.

  Have a look at package generics to get an overview.

  Author:
    Rammi

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static java.util.Comparator<? extends java.lang.Comparable>` | `COMPARABLE_COMPARATOR` Comparator which compares Comparables in their natural order.
    `static PrimitiveBooleanIterator` | `EMPTY_BOOLEAN_ITERATOR` Empty primitive boolean iterator.
    `static PrimitiveByteIterator` | `EMPTY_BYTE_ITERATOR` Empty primitive byte iterator.
    `static PrimitiveCharIterator` | `EMPTY_CHAR_ITERATOR` Empty primitive char iterator.
    `static java.util.PrimitiveIterator.OfDouble` | `EMPTY_DOUBLE_ITERATOR` Empty primitve double iterator.
    `static PrimitiveFloatIterator` | `EMPTY_FLOAT_ITERATOR` Empty primitive float iterator.
    `static int` | `EMPTY_HASH` Hash value for empty collections.
    `static java.util.PrimitiveIterator.OfInt` | `EMPTY_INT_ITERATOR` Empty primitive int iterator.
    `static java.util.PrimitiveIterator.OfLong` | `EMPTY_LONG_ITERATOR` Empty primitive long iterator.
    `static PrimitiveShortIterator` | `EMPTY_SHORT_ITERATOR` Empty primitive short iterator.
    `static Predicate1<java.lang.Object>` | `NOT_NULL` Predicate for filtering out null objects.
    `static Function1<java.lang.Byte,java.lang.Number>` | `NUMBER_TO_BYTE` A type converter allowing any number based type to be converted to a byte value.
    `static Function1<java.lang.Double,java.lang.Number>` | `NUMBER_TO_DOUBLE` A type converter allowing any number based type to be converted to double.
    `static Function1<java.lang.Float,java.lang.Number>` | `NUMBER_TO_FLOAT` A type converter allowing any number based type to be converted to float.
    `static Function1<java.lang.Integer,java.lang.Number>` | `NUMBER_TO_INT` A type converter allowing any number based type to be converted to integer.
    `static Function1<java.lang.Long,java.lang.Number>` | `NUMBER_TO_LONG` A type converter allowing any number based type to be converted to long.
    `static Function1<java.lang.Short,java.lang.Number>` | `NUMBER_TO_SHORT` A type converter allowing any number based type to be converted to short integer.
    `static java.lang.String` | `RELEASE_DATE` Deprecated. Use `ModuleVersion.VERSION` instead, or `ModuleVersionService.iterator()`/`ModuleVersionService.collectServices()` for all modules
    `static Function1<java.lang.Boolean,java.lang.String>` | `STR_TO_BOOLEAN` A converter which converts strings to boolean values.
    `static FragileTypeConverter<java.lang.Byte,java.lang.String>` | `STR_TO_BYTE` A converter which converts strings to byte values, using base 10.
    `static FragileTypeConverter<java.lang.Byte,java.lang.String>` | `STR_TO_BYTE_BASE_16` A converter which converts strings to byte values, using base 16.
    `static FragileTypeConverter<java.lang.Byte,java.lang.String>` | `STR_TO_BYTE_BASE_2` A converter which converts strings to byte values, using base 2.
    `static FragileTypeConverter<java.lang.Byte,java.lang.String>` | `STR_TO_BYTE_BASE_8` A converter which converts strings to byte values, using base 8.
    `static FragileTypeConverter<java.lang.Double,java.lang.String>` | `STR_TO_DOUBLE` A converter which converts strings (in Java number format) to double values.
    `static FragileTypeConverter<java.lang.Float,java.lang.String>` | `STR_TO_FLOAT` A converter which converts strings (in Java number format) to float values.
    `static FragileTypeConverter<java.lang.Integer,java.lang.String>` | `STR_TO_INT` A converter which converts strings to integer, using base 10.
    `static FragileTypeConverter<java.lang.Integer,java.lang.String>` | `STR_TO_INT_BASE_16` A converter which converts strings to integer, using base 16.
    `static FragileTypeConverter<java.lang.Integer,java.lang.String>` | `STR_TO_INT_BASE_2` A converter which converts strings to integer, using base 2.
    `static FragileTypeConverter<java.lang.Integer,java.lang.String>` | `STR_TO_INT_BASE_8` A converter which converts strings to integer, using base 8.
    `static FragileTypeConverter<java.lang.Long,java.lang.String>` | `STR_TO_LONG` A converter which converts strings to long integer, using base 10.
    `static FragileTypeConverter<java.lang.Long,java.lang.String>` | `STR_TO_LONG_BASE_16` A converter which converts strings to long integer, using base 16.
    `static FragileTypeConverter<java.lang.Long,java.lang.String>` | `STR_TO_LONG_BASE_2` A converter which converts strings to long integer, using base 2.
    `static FragileTypeConverter<java.lang.Long,java.lang.String>` | `STR_TO_LONG_BASE_8` A converter which converts strings to long integer, using base 8.
    `static Function1<java.lang.String,java.lang.String>` | `STR_TO_LOWER` A converter which changes strings to lowercase.
    `static FragileTypeConverter<java.lang.Short,java.lang.String>` | `STR_TO_SHORT` A converter which converts strings to short integer, using base 10.
    `static FragileTypeConverter<java.lang.Short,java.lang.String>` | `STR_TO_SHORT_BASE_16` A converter which converts strings to short integer, using base 16.
    `static FragileTypeConverter<java.lang.Short,java.lang.String>` | `STR_TO_SHORT_BASE_2` A converter which converts strings to short integer, using base 2.
    `static FragileTypeConverter<java.lang.Short,java.lang.String>` | `STR_TO_SHORT_BASE_8` A converter which converts strings to short integer, using base 8.
    `static Function1<java.lang.String,java.lang.String>` | `STR_TO_UPPER` A converter which changes strings to uppercase.
    `static Function1<java.lang.String,java.lang.Object>` | `TO_STRING` A type converter which converts any object into its toString() representation.
    `static java.util.Comparator<?>` | `TO_STRING_COMPARATOR` Comparator which compares the toString() representation.
    `static java.util.Comparator<?>` | `TO_STRING_IGNORE_CASE_COMPARATOR` Comparator which compares the toString() representation in case-insensitive order.
    `static java.lang.String` | `VERSION` Deprecated. use `ModuleVersion.VERSION` instead
    `static Function1<java.util.List<java.lang.String>,java.lang.String>` | `WORD_SPLIT` A converter which splits strings into words.

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <C extends java.util.Collection<T>,T> C` | `addAll(C collection, java.util.Enumeration<? extends T> enumeration)` Add all elements of an enumeration to a collection.
    `static <C extends java.util.Collection<T>,T> C` | `addAll(C collection, java.lang.Iterable<? extends T> iterable)` Add all elements of an iterable to a collection.
    `static <C extends java.util.Collection<T>,T> C` | `addAll(C collection, java.util.Iterator<? extends T> iterator)` Add all elements of an iterator to a collection.
    `static <C extends java.util.Collection<? super T>,T> C` | `addAll(C collection, T... elements)` Add all elements to a collection.
    `static <C extends java.util.Collection<T>,T> C` | `addEnumeration(C collection, java.util.Enumeration<? extends T> enumeration)` Deprecated. Use `addAll(Collection, Enumeration)` instead
    `static <C extends java.util.Collection<T>,T> C` | `addIterable(C collection, java.lang.Iterable<? extends T> iterable)` Deprecated. Use `addAll(Collection, Iterable)` instead
    `static <C extends java.util.Collection<T>,T> C` | `addIterator(C collection, java.util.Iterator<? extends T> iterator)` Deprecated. Use `addAll(Collection, Iterator)` instead
    `static <T> boolean` | `all(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker)` Does every element of the enumeration fulfill the predicate?
    `static <T> boolean` | `all(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Does every element in the iterable fulfill the predicate?
    `static <T> boolean` | `all(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker)` Does every element of the iterator fulfill the predicate?
    `static <T> boolean` | `all(T[] array, java.util.function.Predicate<? super T> checker)` Does every element in the array fulfill the predicate?
    `static <T> boolean` | `any(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker)` Does any element of the enumeration fulfill the predicate?
    `static <T> boolean` | `any(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Does any element in the iterable fulfill the predicate?
    `static <T> boolean` | `any(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker)` Does any element of the iterator fulfill the predicate?
    `static <T> boolean` | `any(T[] array, java.util.function.Predicate<? super T> checker)` Does any element in the array fulfill the predicate?
    `static <T1,T2> boolean` | `areEqual(java.util.Collection<T1> c1, java.util.Collection<T2> c2)` Are two collections equal?
    `static <T1,T2> boolean` | `areEqual(java.util.Collection<T1> c1, java.util.Collection<T2> c2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two collections equal?
    `static <T1,T2> boolean` | `areEqual(Countable<T1> c1, Countable<T2> c2)` Are two countables equal?
    `static <T1,T2> boolean` | `areEqual(Countable<T1> c1, Countable<T2> c2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two countables equal?
    `static <T1,T2> boolean` | `areEqual(java.util.Enumeration<T1> en1, java.util.Enumeration<T2> en2)` Are two enumerators equal?
    `static <T1,T2> boolean` | `areEqual(java.util.Enumeration<T1> en1, java.util.Enumeration<T2> en2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two enumerators equal?
    `static <T1,T2> boolean` | `areEqual(java.lang.Iterable<T1> it1, java.lang.Iterable<T2> it2)` Are two iterables equal?
    `static <T1,T2> boolean` | `areEqual(java.lang.Iterable<T1> it1, java.lang.Iterable<T2> it2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two iterables equal?
    `static <T1,T2> boolean` | `areEqual(java.util.Iterator<T1> it1, java.util.Iterator<T2> it2)` Are two iterations equal?
    `static <T1,T2> boolean` | `areEqual(java.util.Iterator<T1> it1, java.util.Iterator<T2> it2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two iterations equal?
    `static <T1,T2> boolean` | `areEqual(T1[] arr1, T2[] arr2)` Are two arrays equal?
    `static <T1,T2> boolean` | `areEqual(T1[] arr1, T2[] arr2, java.util.function.BiPredicate<? super T1,? super T2> matcher)` Are two arrays equal?
    `static <T> boolean` | `areEqualSets(java.util.Collection<T> set1, java.util.Collection<T> set2)` Are the given sets equal.
    `static <T> T` | `as(java.lang.Class<T> type, java.lang.Object obj)` Cast an item to a given type if possible.
    `static <T> java.util.List<T>` | `asList(T... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static <T> java.util.List<T>` | `asList(T[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static <T> java.util.List<T>` | `asList(T[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static <T,S> FragileTypeConverter<T,S>` | `asTypeConverter(FragileFunction1<T,? extends java.lang.Exception,S> function)` Use a fragile function with 1 argument as a type converter.
    `static <S> PrimitiveBooleanIterable` | `booleanView(java.lang.Iterable<S> sourceIterable, java.util.function.Predicate<? super S> booleanMapper)` View a generic iterable as if it is an iterable of primitive `boolean` values.
    `static <S> PrimitiveBooleanIterator` | `booleanView(java.util.Iterator<S> sourceIterator, java.util.function.Predicate<? super S> booleanMapper)` View a generic iterator as if it is an iterator for primitive boolean values.
    `static <S> PrimitiveByteIterable` | `byteView(java.lang.Iterable<S> sourceIterable, ToByteFunction<? super S> byteMapper)` View a generic iterable as if it is an iterable of primitive `byte` values.
    `static <S> PrimitiveByteIterator` | `byteView(java.util.Iterator<S> sourceIterator, ToByteFunction<? super S> byteMapper)` View a generic iterator as if it is an iterator for primitive byte values.
    `static <T> java.util.Enumeration<T>` | `cast(java.util.Enumeration<? extends T> enumeration)` Get a casted enumeration.
    `static <T> java.lang.Iterable<T>` | `cast(java.lang.Iterable<?> iterable)` Get a casted iterable.
    `static <T> java.util.Iterator<T>` | `cast(java.util.Iterator<?> iterator)` Get a casted iterator.
    `static <T,S> Function1<T,S>` | `castConverter()` A converter which converts a type to a any other type by applying a cast.
    `static <S> PrimitiveCharIterable` | `charView(java.lang.Iterable<S> sourceIterable, ToCharFunction<? super S> charMapper)` View a generic iterable as if it is an iterable of primitive `char` values.
    `static <S> PrimitiveCharIterator` | `charView(java.util.Iterator<S> sourceIterator, ToCharFunction<? super S> charMapper)` View a generic iterator as if it is an iterator for primitive char values.
    `static <T> java.util.ArrayList<T>` | `clone(java.util.Collection<T> sourceCollection, java.util.function.Function<T,T> cloner)` Clone a collection.
    `static <T> java.util.ArrayList<T>` | `clone(Countable<T> sourceCountable, java.util.function.Function<T,T> cloner)` Clone a countable.
    `static <T,I,S> Function1<T,S>` | `combine(java.util.function.Function<I,T> secondStep, java.util.function.Function<S,? extends I> firstStep)` Get a combined type converter using an intermediate value.
    `static <T,I,S> FragileTypeConverter<T,S>` | `combineEE(FragileTypeConverter<T,I> secondStep, FragileTypeConverter<? extends I,S> firstStep)` Get a combined type converter using an intermediate value.
    `static <T,I,S> FragileTypeConverter<T,S>` | `combineEF(FragileTypeConverter<T,I> secondStep, java.util.function.Function<S,? extends I> firstStep)` Get a combined type converter using an intermediate value.
    `static <T,I,S> FragileTypeConverter<T,S>` | `combineFE(java.util.function.Function<I,T> secondStep, FragileTypeConverter<? extends I,S> firstStep)` Get a combined type converter using an intermediate value.
    `static <T> java.lang.Iterable<T>` | `concat(java.lang.Iterable<? extends T>... iterables)` Concatenate some iterables to a combined iterable.
    `static <T> java.util.Iterator<T>` | `concat(java.util.Iterator<? extends T>... iterators)` Concatenate some iterators.
    `static <T> java.lang.Iterable<T>` | `concatIterables(java.lang.Iterable<? extends java.lang.Iterable<? extends T>> iterables)` Concatenate some iterables to a combined iterable.
    `static <T> java.util.Iterator<T>` | `concatIterators(java.lang.Iterable<? extends java.util.Iterator<? extends T>> iterators)` Concatenate some iterators.
    `static <T,E> boolean` | `contains(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Is an element contained in an enumeration?
    `static <T,E> boolean` | `contains(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Is an element contained in an iterable?
    `static <T,E> boolean` | `contains(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Is an element contained in an iterator?
    `static <T,E> boolean` | `contains(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Is an element contained in an array?
    `static <T> boolean` | `containsAny(java.util.Collection<T> set, java.lang.Iterable<? extends T> possibleElements)` Check whether any of a bunch of elements is contained in a collection.
    `static <T> boolean` | `containsEquals(java.lang.Iterable<T> collection, T element)` Test whether a collection contains an element which is equal to another element.
    `static <T extends Copyable<T>,C extends java.util.Collection<T>> C` | `copy(C target, java.util.Enumeration<T> enumeration)` Get a copy of an enumeration while copying the content.
    `static <T extends Copyable<T>,C extends java.util.Collection<T>> C` | `copy(C target, java.lang.Iterable<T> iterable)` Get a copy of an iterable, while copying the content.
    `static <T extends Copyable<T>,C extends java.util.Collection<T>> C` | `copy(C target, java.util.Iterator<T> iterator)` Get a copy of an iterator while copying the content.
    `static <T extends Copyable<T>> java.util.ArrayList<T>` | `copy(java.util.Collection<T> collection)` Get a copy of a collection, while copying the content.
    `static <T extends Copyable<T>> java.util.ArrayList<T>` | `copy(Countable<T> countable)` Get a copy of a countable, while copying the content.
    `static <T extends Copyable<T>,C extends java.util.Collection<T>> C` | `copy(C target, T[] array)` Get a copy of an array, while copying the content.
    `static <T extends Copyable<T>> java.util.LinkedList<T>` | `copy(java.util.Enumeration<T> enumeration)` Get a copy of an enumeration, while copying the content.
    `static <T extends Copyable<T>> java.util.ArrayList<T>` | `copy(Indexable<T> indexable)` Get a copy of a indexable, while copying the content.
    `static <T extends Copyable<T>> java.util.LinkedList<T>` | `copy(java.lang.Iterable<T> iterable)` Get a copy of an iterable, while copying the content.
    `static <T extends Copyable<T>> java.util.LinkedList<T>` | `copy(java.util.Iterator<T> iterator)` Get a copy of an iterator, while copying the content.
    `static <T extends Copyable<T>> java.util.ArrayList<T>` | `copy(T[] array)` Get a copy of an array, while copying the content.
    `static <T,S> TwoWayTypeConverter<T,S>` | `createTwoWay(java.util.function.Function<S,T> toConverter, java.util.function.Function<T,S> backConverter)` Create a two way type converter from two one way type converters.
    `static <S> PrimitiveDoubleIterable` | `doubleView(java.lang.Iterable<S> sourceIterable, java.util.function.ToDoubleFunction<? super S> doubleMapper)` View a generic iterable as if it is an iterable of primitive `double` values.
    `static <S> java.util.PrimitiveIterator.OfDouble` | `doubleView(java.util.Iterator<S> sourceIterator, java.util.function.ToDoubleFunction<? super S> doubleMapper)` View a generic iterator as if it is an iterator for primitive double values.
    `static <T> java.util.Enumeration<T>` | `downCast(java.util.Enumeration<? extends T> enumeration)` Get a down-casted enumeration.
    `static <T,S> java.util.function.Function<S,T>` | `downCast(java.util.function.Function<? super S,? extends T> typeConverter)` Downcast a type converter.
    `static <T> java.lang.Iterable<T>` | `downCast(java.lang.Iterable<? extends T> iterable)` Get a down-casted iterable.
    `static <T> java.util.Iterator<T>` | `downCast(java.util.Iterator<? extends T> iterator)` Get a down-casted iterator.
    `static <T,S> FragileTypeConverter<T,S>` | `downCastT(FragileTypeConverter<? extends T,? super S> typeConverter)` Downcast a type converter.
    `static <T,S extends T> Function1<T,S>` | `downConverter()` A converter which converts a type to a more basic type.
    `static <T> java.util.Enumeration<T>` | `emptyEnumeration()` Return an empty enumeration which does not iterate.
    `static <T> java.lang.Iterable<T>` | `emptyIterable()` Return an empty iterable which does not iterate.
    `static <T> java.util.Iterator<T>` | `emptyIterator()` Return an empty iterator which does not iterate.
    `static <T> java.util.ListIterator<T>` | `emptyListIterator()` Return an empty list iterator which does not iterate.
    `static <T,C extends java.util.Collection<? super T>> C` | `extract(C target, java.util.Enumeration<?> enumeration, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T,C extends java.util.Collection<? super T>> C` | `extract(C target, java.lang.Iterable<?> iterable, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T,C extends java.util.Collection<? super T>> C` | `extract(C target, java.util.Iterator<?> iterator, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T,C extends java.util.Collection<? super T>> C` | `extract(C target, java.lang.Object[] array, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T> java.util.LinkedList<T>` | `extract(java.util.Enumeration<?> enumeration, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T> java.util.LinkedList<T>` | `extract(java.lang.Iterable<?> iterable, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T> java.util.LinkedList<T>` | `extract(java.util.Iterator<?> iterator, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T> java.util.LinkedList<T>` | `extract(java.lang.Object[] array, java.lang.Class<T> targetType)` Extract all elements of a given type.
    `static <T1,T2> java.util.function.BiPredicate<T1,T2>` | `falseBiPredicate()` Return a bi-predicate which returns always `false`.
    `static <T> java.util.function.Predicate<T>` | `falsePredicate()` Return a predicate which returns always `false`.
    `static <T> void` | `fillArray(T[] array, int start, int length, java.util.function.Supplier<? extends T> supplier)` Fill part of an array with elements provided by a supplier.
    `static <T> void` | `fillArray(T[] array, java.util.function.Supplier<? extends T> supplier)` Fill an array with elements provided by a supplier.
    `static <T> void` | `fillTight(java.util.ArrayList<T> list, java.util.Collection<? extends T> elements)` Fill an array list with a number of alements.
    `static <T,S> void` | `fillTight(java.util.ArrayList<T> list, java.util.Collection<S> elements, java.util.function.Function<? super S,? extends T> mapper)` Fill an array list with a number of elements.
    `static <T> void` | `fillTight(java.util.ArrayList<T> list, Countable<? extends T> elements)` Fill an array list with a number of alements.
    `static <T,S> void` | `fillTight(java.util.ArrayList<T> list, Countable<S> elements, java.util.function.Function<? super S,? extends T> mapper)` Fill an array list with a number of elements.
    `static <T> void` | `fillTight(java.util.ArrayList<T> list, java.lang.Iterable<? extends T> elements)` Fill an array list with a number of alements.
    `static <T,S> void` | `fillTight(java.util.ArrayList<T> list, java.lang.Iterable<S> elements, java.util.function.Function<? super S,? extends T> mapper)` Fill an array list with a number of elements.
    `static <C extends java.util.Collection<? super T>,T> C` | `filter(C target, java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker)` Filter the elements of an enumeration into a collection.
    `static <C extends java.util.Collection<? super T>,T> C` | `filter(C target, java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Filter the elements of an iterable into a collection.
    `static <C extends java.util.Collection<? super T>,T> C` | `filter(C target, java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker)` Filter the elements of an iterator into a collection.
    `static <C extends java.util.Collection<? super T>,T> C` | `filter(C target, T[] array, java.util.function.Predicate<? super T> filter)` Filter the elements of an array into a collection.
    `static <T> java.util.LinkedList<T>` | `filter(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker)` Filter the elements of an enumeration into a result list.
    `static <T> java.util.LinkedList<T>` | `filter(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Filter the elements of an iterable into a collection.
    `static <T> java.util.LinkedList<T>` | `filter(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker)` Filter the elements of an iterator into a collection.
    `static <T> java.util.LinkedList<T>` | `filter(T[] array, java.util.function.Predicate<? super T> checker)` Filter the elements of an array into a collection.
    `static <T> boolean` | `filterOut(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> outCheck)` Filter a modifiable iterable inline.
    `static <K,V> java.util.Set<java.util.Map.Entry<K,V>>` | `findAllEntries(java.util.Map<K,V> map, Predicate2<? super K,? super V> entryChecker)` Return all entries which which the given checker accepts.
    `static <K,V> java.util.Map.Entry<K,V>` | `findAnyEntry(java.util.Map<K,V> map, Predicate2<? super K,? super V> entryChecker)` Find the first entry in a map which the given entry checker accepts.
    `static <K,V> K` | `findAnyKey(java.util.Map<K,V> map, java.util.function.Predicate<? super V> valueChecker)` Find the first key in a map which the given value checker accepts.
    `static <T> T` | `findFirst(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> check)` Find the first element which fulfills the given check.
    `static <T> int` | `findFirstEqual(java.lang.Iterable<T> collection, T element)` Find the first element in an collection which is equal to another element.
    `static <T,E> int` | `findFirstMatch(java.lang.Iterable<T> collection, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Find the first element in a collection which is matching another element.
    `static <T> T` | `findNext(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> check)` Find the nect element which fulfils the given check.
    `static <T> T` | `findNext(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> check)` Find the nect element which fulfils the given check.
    `static <T> T` | `first(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Get the first element which fulfills a check.
    `static <T> java.util.LinkedList<T>` | `flatten(java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)` Flatten a collection of collections.
    `static <T,R extends java.util.Collection<? super T>> R` | `flatten(R target, java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)` Flatten a collection of collections.
    `static <S> PrimitiveFloatIterable` | `floatView(java.lang.Iterable<S> sourceIterable, ToFloatFunction<? super S> floatMapper)` View a generic iterable as if it is an iterable of primitive `float` values.
    `static <S> PrimitiveFloatIterator` | `floatView(java.util.Iterator<S> sourceIterator, ToFloatFunction<? super S> floatMapper)` View a generic iterator as if it is an iterator for primitive float values.
    `static <V,T> V` | `foldLeft(java.util.Enumeration<T> enumeration, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do left-associative folding of an enumeration.
    `static <V,T> V` | `foldLeft(java.lang.Iterable<T> iterable, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do left-associative folding of an iterable.
    `static <V,T> V` | `foldLeft(java.util.Iterator<T> iterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do left-associative folding of an iterator.
    `static <V,T> V` | `foldLeft(T[] array, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do left-associative folding of an array.
    `static <V,T> V` | `foldRight(java.util.Enumeration<T> enumeration, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of an enumeration.
    `static <V,T> V` | `foldRight(java.lang.Iterable<T> iterable, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of an iterable.
    `static <V,T> V` | `foldRight(java.util.Iterator<T> iterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of an iteration.
    `static <V,T> V` | `foldRight(java.util.List<T> list, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of a list.
    `static <V,T> V` | `foldRight(java.util.ListIterator<T> reverseIterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of a list iterator using it in reverse direction.
    `static <V,T> V` | `foldRight(T[] array, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder)` Do right-associative folding of an array.
    `static <T,E extends java.lang.Exception> void` | `forEach(java.util.Enumeration<T> enumeration, FragileLoopItemHandler<? super T,E> handler)` Call a handler for each item in an enumeration
    `static <T> void` | `forEach(java.util.Enumeration<T> enumeration, LoopItemHandler<? super T> handler)` Call a handler for each item in an enumeration.
    `static <T,E extends java.lang.Exception> void` | `forEach(java.lang.Iterable<T> iterable, FragileLoopItemHandler<? super T,E> handler)` Call a handler for each item in an iterable.
    `static <T> void` | `forEach(java.lang.Iterable<T> iterable, LoopItemHandler<? super T> handler)` Call a handler for each item in an iterable.
    `static <T,E extends java.lang.Exception> void` | `forEach(java.util.Iterator<T> iterator, FragileLoopItemHandler<? super T,E> handler)` Call a handler for each item in an iterator
    `static <T> void` | `forEach(java.util.Iterator<T> iterator, LoopItemHandler<? super T> handler)` Call a handler for each item in an iterator.
    `static <T,E extends java.lang.Exception> void` | `forEach(T[] array, FragileLoopItemHandler<? super T,E> handler)` Call a handler for each item in an array.
    `static <T> void` | `forEach(T[] array, LoopItemHandler<? super T> handler)` Call a handler for each item in an array.
    `static <T,E extends java.lang.Exception> void` | `forEachFragile(java.lang.Iterable<T> iterable, FragileProcedure1<E,? super T> consumer)` Foreach implementation which can be used with consumers which might throw a checked exception.
    `static <T,E extends java.lang.Exception> void` | `forEachRemainingFragile(java.util.Iterator<T> iterator, FragileProcedure1<E,? super T> consumer)` Foreach remaining implementation which can be used with consumers which might throw a checked exception.
    `static <T> T` | `get(java.lang.Iterable<T> iterable, int index)` Get the nth element of an iterable.
    `static <T extends Copyable<T>> java.util.function.Function<T,T>` | `getCopier(java.lang.Class<T> elemClass)` Get a copier function which creates an copy of its argument.
    `static int` | `hash(java.lang.Iterable<?> iterable)` Calculate a hash code for a generic iterable.
    `static Indexable<java.lang.Byte>` | `indexable(byte... array)` Return an indexable from a primitive byte integer array.
    `static Indexable<java.lang.Double>` | `indexable(double... array)` Return an indexable from a primitive double array.
    `static Indexable<java.lang.Float>` | `indexable(float... array)` Return an indexable from a primitive float array.
    `static Indexable<java.lang.Integer>` | `indexable(int... array)` Return an indexable from a primitive integer array.
    `static Indexable<java.lang.Long>` | `indexable(long... array)` Return an indexable from a primitive long integer array.
    `static Indexable<java.lang.Short>` | `indexable(short... array)` Return an indexable from a primitive short integer array.
    `static <T,E> int` | `indexOf(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the first index where a given element appears.
    `static <T,E> int` | `indexOf(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the first index where a given element appears.
    `static <S> PrimitiveIntIterable` | `intView(java.lang.Iterable<S> sourceIterable, java.util.function.ToIntFunction<? super S> intMapper)` View a generic iterable as if it is an iterable of primitive `int` values.
    `static <S> java.util.PrimitiveIterator.OfInt` | `intView(java.util.Iterator<S> sourceIterator, java.util.function.ToIntFunction<? super S> intMapper)` View a generic iterator as if it is an iterator for primitive int values.
    `static <T,S> TwoWayTypeConverter<T,S>` | `invert(TwoWayTypeConverter<S,T> typeConverter)` Get an inverted two way type converter from a given one.
    `static boolean` | `isEmptyOrNull(java.lang.String str)` Check whether a string is empty or `null`.
    `static boolean` | `isWhiteOrNull(java.lang.String str)` Check whether a string is empty, contains only whitespace, or is `null`.
    `static java.lang.String` | `join(char glue, java.lang.Iterable<java.lang.String> strings)` Join a bunch of strings into one.
    `static java.lang.String` | `join(char glue, java.util.Iterator<java.lang.String> strings)` Join a bunch of strings into one.
    `static java.lang.String` | `join(char glue, java.lang.String... strings)` Join an array of strings into one.
    `static java.lang.String` | `join(java.lang.String glue, java.util.Enumeration<java.lang.String> strings)` Join a bunch of strings into one.
    `static java.lang.String` | `join(java.lang.String glue, java.lang.Iterable<java.lang.String> strings)` Join a bunch of strings into one.
    `static java.lang.String` | `join(java.lang.String glue, java.util.Iterator<java.lang.String> strings)` Join a bunch of strings into one.
    `static java.lang.String` | `join(java.lang.String glue, java.lang.String... strings)` Join an array of strings into one.
    `static <T> T` | `last(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker)` Get the last element which fulfills a check.
    `static <T> T` | `last(java.util.List<T> list, java.util.function.Predicate<? super T> checker, int startIndex)` Get the last element which fulfills a check.
    `static <T,E> int` | `lastIndexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the last index where a given element appears.
    `static <T,E> int` | `lastIndexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the last index where a given element appears.
    `static <T,E> T` | `lastMatch(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher)` Get the last matching element where a given element appears.
    `static <T,E> T` | `lastMatch(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start)` Get the last matching element from a list.
    `static <T extends java.lang.Comparable<T>> int` | `lexicalCompare(java.lang.Iterable<? extends T> it1, java.lang.Iterable<? extends T> it2)` Compare two iterables in lexical natural order.
    `static <T> int` | `lexicalCompare(java.lang.Iterable<? extends T> it1, java.lang.Iterable<? extends T> it2, java.util.Comparator<T> comparator)` Compare two iterables in lexical order.
    `static <T extends java.lang.Comparable<T>> int` | `lexicalCompare(java.util.Iterator<? extends T> it1, java.util.Iterator<? extends T> it2)` Compare two iterators in lexical natural order.
    `static <T> int` | `lexicalCompare(java.util.Iterator<? extends T> it1, java.util.Iterator<? extends T> it2, java.util.Comparator<T> comparator)` Compare two iterators in lexical order.
    `static <S> PrimitiveLongIterable` | `longView(java.lang.Iterable<S> sourceIterable, java.util.function.ToLongFunction<? super S> longMapper)` View a generic iterable as if it is an iterable of primitive `long` values.
    `static <S> java.util.PrimitiveIterator.OfLong` | `longView(java.util.Iterator<S> sourceIterator, java.util.function.ToLongFunction<? super S> longMapper)` View a generic iterator as if it is an iterator for primitive long values.
    `static <T> ArrayFactory<T>` | `makeArrayFactory(java.lang.Class<T> type)` Create an array factory from a type.
    `static <T> Factory<T>` | `makeFactory(java.lang.Class<T> type)` Create a factory from a type.
    `static <T> java.util.LinkedList<T>` | `makeList(java.util.Enumeration<T> enumeration)` Create a list from an enumeration.
    `static <T> java.util.LinkedList<T>` | `makeList(java.lang.Iterable<T> iterable)` Create a list from an iterable.
    `static <T> java.util.LinkedList<T>` | `makeList(java.util.Iterator<T> iterator)` Create a list from an iterator.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iteration into a collection.
    `static <C extends java.util.function.Consumer<? super T>,T,S> C` | `map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iteration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iteration into a collection.
    `static <C extends java.util.function.Consumer<? super T>,T,S> C` | `map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iteration to a consumer.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iterator into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a collection.
    `static <C extends java.util.function.Consumer<? super T>,T,S> C` | `map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator to a consumer.
    `static <T,S> java.util.ArrayList<T>` | `map(java.util.Collection<S> collection, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of a collection.
    `static <T,S> java.util.ArrayList<T>` | `map(Countable<S> countable, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of a countable.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, S[] array, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an array into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `map(C target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an array into a collection.
    `static <T,S> java.util.LinkedList<T>` | `map(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <T,S> java.util.LinkedList<T>` | `map(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a collection.
    `static <T,S> java.util.LinkedList<T>` | `map(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterable.
    `static <T,S> java.util.LinkedList<T>` | `map(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an iterable.
    `static <T,S> java.util.LinkedList<T>` | `map(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterator.
    `static <T,S> java.util.LinkedList<T>` | `map(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a collection.
    `static <KT,VT,KS,VS> java.util.HashMap<KT,VT>` | `map(java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<KS,VS>,java.util.Map.Entry<KT,VT>> typeConverter)` Map one map into another, while allowing to discard elements on the way.
    `static <MT extends java.util.Map<KT,VT>,KT,VT,KS,VS> MT` | `map(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter)` Map one map into another, while allowing to discard elements on the way.
    `static <T,S> java.util.ArrayList<T>` | `map(S[] array, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an array.
    `static <T,S> java.util.LinkedList<T>` | `map(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an array.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Collection, Enumeration, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Collection, Enumeration, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Collection, Iterable, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Collection, Iterable, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Collection, Iterator, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Collection, Iterator, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, S[] array, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Collection, Object[], FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapE(C target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Collection, Object[], FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Enumeration, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Enumeration, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Iterable, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Iterable, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Iterator, FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Iterator, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(S[] array, FragileTypeConverter<T,? super S> typeConverter)` Deprecated. use `mapFragile(Object[], FragileFunction1)` instead which does not require handling a `TypeConverterException`
    `static <T,S> java.util.LinkedList<T>` | `mapE(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Deprecated. use `mapFragile(Object[], FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
    `static <KT,VT,KS,VS> Function1<java.util.Map.Entry<KT,VT>,java.util.Map.Entry<KS,VS>>` | `mapEntryConverter(java.util.function.Function<KS,KT> keyConverter, java.util.function.Function<VS,VT> valueConverter)` Type converter which converts a map entry by simultaneously applying a converter to the key and to the value.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper)` Add the mapped elements of an enumeration into a collection by using a mapper function which might throw a checked exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Add the mapped elements of an enumeration into a collection while using a mapper which might throw an exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper)` Add the mapped elements of an iterable into a collection by using a mapper function which might throw a checked exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Add the mapped elements of an iterable into a collection while using a mapper which might throw an exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper)` Add the mapped elements of an iterator into a collection by using a mapper function which might throw a checked exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Add the mapped elements of an iterator into a collection while using a mapper which might throw an exception.
    `static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>` | `mapFragile(java.util.Collection<S> collection, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of a collection while using a mapper which might throw a checked exception.
    `static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>` | `mapFragile(Countable<S> countable, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of an array while using a mapper which might throw a checked exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, S[] array, FragileFunction1<? extends T,E,? super S> mapper)` Add the mapped elements of an array into a collection by using a mapper function which might throw a checked exception.
    `static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C` | `mapFragile(C target, S[] array, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Add the mapped elements of an array into a collection while using a mapper which might throw an exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of an enumeration while using a mapper which might throw a checked exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Get the mapped elements of an enumeration while using a mapper which might throw an exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of an iterable while using a mapper which might throw a checked exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Get the mapped elements of an iterable while using a mapper which might throw an exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of an iterator while using a mapper which might throw a checked exception.
    `static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>` | `mapFragile(java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Get the mapped elements of an iterator while using a mapper which might throw an exception.
    `static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>` | `mapFragile(S[] array, FragileFunction1<? extends T,E,? super S> mapper)` Get the mapped elements of an array while using a mapper which might throw a checked exception.
    `static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>` | `mapFragile(S[] array, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark)` Get the mapped elements of an array while using a mapper which might throw an exception.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterable as a hash map..
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an iterable to a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterator as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, S[] array, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an array into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapM(M target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an array into a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(S[] array, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapM(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an enumeration to a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an iterable as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Get the mapped elements of an iterable as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an iterator as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an enumeration to a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an enumeration to a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an iterator to a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an array into a map.
    `static <M extends java.util.Map<? super T,? super S>,T,S> M` | `mapME(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an array into a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(S[] array, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<T,S>` | `mapME(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterable as a hash map..
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an iterable to a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an iterator as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an enumeration into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, S[] array, java.util.function.Function<? super S,T> typeConverter)` Add the mapped elements of an array into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapR(M target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Add the mapped elements of an array into a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(S[] array, java.util.function.Function<? super S,T> typeConverter)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapR(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an enumeration into a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an enumeration to a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an iterable as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Get the mapped elements of an iterable as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an iterator as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an enumeration to a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an enumeration to a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iteration into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an iterator to a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an iterator into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter)` Add the mapped elements of an array into a map.
    `static <M extends java.util.Map<? super S,? super T>,T,S> M` | `mapRE(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Add the mapped elements of an array into a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(S[] array, FragileTypeConverter<T,? super S> typeConverter)` Get the mapped elements of an array as a map.
    `static <T,S> java.util.HashMap<S,T>` | `mapRE(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark)` Get the mapped elements of an array as a map.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapX(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapX(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Add the mapped elements of an iteration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapX(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Add the mapped elements of an iterator into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapX(C target, S[] array, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Add the mapped elements of an array into a collection.
    `static <T,S> java.util.LinkedList<T>` | `mapX(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <T,S> java.util.LinkedList<T>` | `mapX(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Get the mapped elements of an iterable.
    `static <T,S> java.util.LinkedList<T>` | `mapX(java.util.Iterator<S> iterator, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Get the mapped elements of an iterator.
    `static <KT,VT,KS,VS> java.util.HashMap<KT,VT>` | `mapX(java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,java.lang.Iterable<java.util.Map.Entry<KT,VT>>> typeConverter)` Map one map into another, while allowing to discard elements on the way.
    `static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT` | `mapX(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter)` Map one map into another, allowing to discard or add elements on the way.
    `static <T,S> java.util.LinkedList<T>` | `mapX(S[] array, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)` Get the mapped elements of an array.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapXE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapXE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Add the mapped elements of an iteration into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapXE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Add the mapped elements of an iterator into a collection.
    `static <C extends java.util.Collection<? super T>,T,S> C` | `mapXE(C target, S[] array, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Add the mapped elements of an array into a collection.
    `static <T,S> java.util.LinkedList<T>` | `mapXE(java.util.Enumeration<S> enumeration, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Add the mapped elements of an enumeration into a collection.
    `static <T,S> java.util.LinkedList<T>` | `mapXE(java.lang.Iterable<S> iterable, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Get the mapped elements of an iterable.
    `static <T,S> java.util.LinkedList<T>` | `mapXE(java.util.Iterator<S> iterator, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Get the mapped elements of an iterator.
    `static <T,S> java.util.LinkedList<T>` | `mapXE(S[] array, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)` Get the mapped elements of an array.
    `static <T> T` | `max(java.util.Comparator<? super T> comparator, java.lang.Iterable<T> values)` Get the maximal value from some values.
    `static <T> T` | `max(java.util.Comparator<? super T> comparator, T... values)` Get the maximal value from an array of values.
    `static <T extends java.lang.Comparable<? super T>> T` | `max(java.lang.Iterable<T> values)` Get the maximal value from some comparable values.
    `static <T extends java.lang.Comparable<? super T>> T` | `max(T... values)` Get the maximal value from an array of comparable values.
    `static byte` | `maxByte(byte... values)` Get the maximal value.
    `static char` | `maxChar(char... values)` Get the maximal value.
    `static double` | `maxDouble(double... values)` Get the maximal value.
    `static double` | `maxDouble(java.lang.Iterable<? extends java.lang.Number> iterable)` Get the maximal double value for an iterable of numbers.
    `static <T> double` | `maxDouble(java.lang.Iterable<T> iterable, java.util.function.ToDoubleFunction<? super T> toDouble)` Get the maximal double value from a double view of an iterable.
    `static float` | `maxFloat(float... values)` Get the maximal value.
    `static int` | `maxInt(int... values)` Get the maximal value.
    `static long` | `maxLong(long... values)` Get the maximal value.
    `static short` | `maxShort(short... values)` Get the maximal value.
    `static <T> T` | `min(java.util.Comparator<? super T> comparator, java.lang.Iterable<T> values)` Get the minimal value from some values.
    `static <T> T` | `min(java.util.Comparator<? super T> comparator, T... values)` Get the minimal value from an array of values.
    `static <T extends java.lang.Comparable<? super T>> T` | `min(java.lang.Iterable<T> values)` Get the minimal value from some comparable values.
    `static <T extends java.lang.Comparable<? super T>> T` | `min(T... values)` Get the minimal value from an array of comparable values.
    `static byte` | `minByte(byte... values)` Get the minimal value.
    `static char` | `minChar(char... values)` Get the minimal value.
    `static double` | `minDouble(double... values)` Get the minimal value.
    `static double` | `minDouble(java.lang.Iterable<? extends java.lang.Number> iterable)` Get the minimal double value for an iterable of numbers.
    `static <T> double` | `minDouble(java.lang.Iterable<T> iterable, java.util.function.ToDoubleFunction<? super T> toDouble)` Get the minimal double value from a double view of an iterable.
    `static float` | `minFloat(float... values)` Get the minimal value.
    `static int` | `minInt(int... values)` Get the minimal value.
    `static long` | `minLong(long... values)` Get the minimal value.
    `static short` | `minShort(short... values)` Get the minimal value.
    `static java.lang.String` | `multiple(char ch, int count)` Create a string from multiple repetitions of a character.
    `static java.lang.String` | `multiple(java.lang.String str, int count)` Create a string from a base string repeated multiple times.
    `static <T extends java.lang.Comparable<T>> java.util.Comparator<T>` | `naturalOrder()` Get a comparator which sorts comparables in their natural order.
    `static <T extends java.lang.Comparable<T>> java.util.Comparator<T>` | `naturalOrder(java.lang.Class<T> type)` Deprecated. use `naturalOrder()` instead
    `static <T extends java.lang.Comparable<T>> java.util.Comparator<T>` | `naturalOrder(java.util.Collection<T> list)` Deprecated. use `naturalOrder()` instead
    `static java.lang.String` | `notEmpty(java.lang.String str, java.lang.String fallback)` Make sure a string is neither `null` nor empty.
    `static java.lang.String` | `notNull(java.lang.String str)` Make sure a string is not `null`.
    `static <T,D extends T> T` | `notNull(T item, D defaultValue)` Make sure that something is not `null`.
    `static <T> T` | `notNullOr(T item, java.util.function.Supplier<? extends T> provider)` Make sure that something is not `null`, but postpone the fallback creation.
    `static <T> T` | `notNullOrN(T item, java.util.function.Supplier<? extends T> provider)` Try to determine a fallback when a value is `null`.
    `static <T> Function1<T,T>` | `nullConverter()` Type converter which does no conversion.
    `static <T> T` | `requireNonNull(T item, Procedure0 thrower)` Require an item to be not null.
    `static <T> java.util.List<T>` | `reversedList(java.util.List<T> list)` Create a list in reverse order for a given list.
    `static <T> void` | `separate(java.lang.Iterable<T> elements, java.util.Collection<? super T> trueCollect, java.util.Collection<? super T> falseCollect, java.util.function.Predicate<? super T> condition)` Go over an iterable and sepparate its elements depending a condition.
    `static <T> void` | `separate(java.lang.Iterable<T> elements, java.util.function.Consumer<? super T> trueCollect, java.util.function.Consumer<? super T> falseCollect, java.util.function.Predicate<? super T> condition)` Go over an iterable and sepparate its elements depending a condition.
    `static <T> Pair<java.util.LinkedList<T>>` | `separate(java.lang.Iterable<T> elements, java.util.function.Predicate<? super T> condition)` Go over an iterable and separate its elements into two lists depending on a condition.
    `static <T,C extends java.util.Collection<? super T>> Pair<C>` | `separate(java.lang.Iterable<T> elements, java.util.function.Supplier<C> slotCreator, java.util.function.Predicate<? super T> condition)` Fo over an iterable and separate its elements depending on a condition.
    `static <S> PrimitiveShortIterable` | `shortView(java.lang.Iterable<S> sourceIterable, ToShortFunction<? super S> shortMapper)` View a generic iterable as if it is an iterable of primitive `short` values.
    `static <S> PrimitiveShortIterator` | `shortView(java.util.Iterator<S> sourceIterator, ToShortFunction<? super S> shortMapper)` View a generic iterator as if it is an iterator for primitive short values.
    `static java.lang.String` | `spaces(int count)` This creates a string consisting only of spaces which is sometimes useful.
    `static <T> java.util.Collection<T>` | `synchronizedCollection(java.util.Collection<T> collection)` Get a synchronized collection from a basic collection which is optimized for being often iterated, but rarely changed.
    `static <T> java.util.List<T>` | `synchronizedList(java.util.List<T> list)` Get a synchronized list from a basic collection which is optimized for being often iterated, but rarely changed.
    `static boolean[]` | `toBooleanArray(java.util.Collection<java.lang.Boolean> c)` Convert a collection of `Boolean`s to a raw array of booleans.
    `static boolean[]` | `toBooleanArray(Countable<java.lang.Boolean> c)` Convert a countable of `Boolean`s to a raw array of booleans.
    `static byte[]` | `toByteArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of bytes.
    `static byte[]` | `toByteArray(Countable<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of bytes.
    `static byte[]` | `toByteArray(int... bytes)` Convert a number of bytes into a byte array.
    `static double[]` | `toDoubleArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of doubles.
    `static double[]` | `toDoubleArray(Countable<? extends java.lang.Number> c)` Convert a countable of `Number`s to a raw array of doubles.
    `static <T> java.util.Enumeration<T>` | `toEnumeration(java.lang.Iterable<T> iterable)` Convert an iterable into an enumeration.
    `static <T> java.util.Enumeration<T>` | `toEnumeration(java.util.Iterator<T> iterator)` Convert an iterator into an enumeration.
    `static <T> java.util.Enumeration<T>` | `toEnumeration(T... item)` Convert some items into an enumeration.
    `static float[]` | `toFloatArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of floats.
    `static float[]` | `toFloatArray(Countable<? extends java.lang.Number> c)` Convert a countable of `Number`s to a raw array of floats.
    `static <T,S> OverCaringTypeConverter<T,S>` | `toFragile(java.util.function.Function<S,T> typeConverter)` Make a non-fragile type converter appear as fragile.
    `static int[]` | `toIntArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of ints.
    `static int[]` | `toIntArray(Countable<? extends java.lang.Number> c)` Convert a countable of `Number`s to a raw array of ints.
    `static <T> java.lang.Iterable<T>` | `toIterable(java.util.Enumeration<T> enumeration)` Get a one shot iterable from an enumeration.
    `static <T> java.util.Iterator<T>` | `toIterator(java.util.Enumeration<T> enumeration)` Convert an enumeration into an iterator.
    `static <T> java.util.Iterator<T>` | `toIterator(T... item)` Convert some items into an iterator.
    `static java.util.List<java.lang.Boolean>` | `toList(boolean... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Boolean>` | `toList(boolean[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Boolean>` | `toList(boolean[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Byte>` | `toList(byte... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Byte>` | `toList(byte[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Byte>` | `toList(byte[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Double>` | `toList(double... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Double>` | `toList(double[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Double>` | `toList(double[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static <T> java.util.LinkedList<T>` | `toList(java.util.Enumeration<T> enumeration)` Collect an enumeration into a linked list.
    `static java.util.List<java.lang.Float>` | `toList(float... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Float>` | `toList(float[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Float>` | `toList(float[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Integer>` | `toList(int... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Integer>` | `toList(int[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Integer>` | `toList(int[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static <T> java.util.LinkedList<T>` | `toList(java.lang.Iterable<T> iterable)` Collect the elements of an iterable into a linked list.
    `static <T> java.util.LinkedList<T>` | `toList(java.util.Iterator<T> iterator)` Collect an iterator into a linked list.
    `static java.util.List<java.lang.Long>` | `toList(long... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Long>` | `toList(long[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Long>` | `toList(long[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Short>` | `toList(short... array)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Short>` | `toList(short[] array, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static java.util.List<java.lang.Short>` | `toList(short[] array, int start, int length)` A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.
    `static long[]` | `toLongArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of long ints.
    `static long[]` | `toLongArray(Countable<? extends java.lang.Number> c)` Convert a countable of `Number`s to a raw array of long ints.
    `static <T,E extends java.lang.Exception,L extends FragileLoopItemHandler<T,E>> CarelessLoopItemHandler<T,E,L>` | `toLoopItemHandler(L handler)` Wrap a careful loop item handler as a simple loop item handler.
    `static <T,S> CarelessTypeConverter<T,S>` | `toNonFragile(FragileTypeConverter<T,S> fragileTypeConverter)` Make a fragile type converter appear as a standard type converter.
    `static <T,S> CarelessTypeConverter<T,S>` | `toNonFragile(FragileTypeConverter<T,S> fragileTypeConverter, T defaultValue)` Make a fragile type converter appear as a standard type converter.
    `static <K,V,C extends java.util.Collection<OrderedPair<K,V>>> C` | `toPairs(C target, java.util.Map<K,V> map)` Get all entries of a map as a collection of ordered pairs.
    `static <K,V> java.util.ArrayList<OrderedPair<K,V>>` | `toPairs(java.util.Map<K,V> map)` Get all entries of a map as a list of ordered pairs.
    `static <R> Function0<R>` | `toRobustF0(FragileFunction0<? extends R,?> fragileFunction)` Convert a fragile zero-argument function which could throw an exception into non-fragile one.
    `static <R,P> Function1<R,P>` | `toRobustF1(FragileFunction1<? extends R,?,? super P> fragileFunction)` Convert a fragile one-argument function which could throw an exception into non-fragile one.
    `static <R,P1,P2> Function2<R,P1,P2>` | `toRobustF2(FragileFunction2<? extends R,?,? super P1,? super P2> fragileFunction)` Convert a fragile two-argument function which could throw an exception into non-fragile one.
    `static <R,P1,P2,P3> Function3<R,P1,P2,P3>` | `toRobustF3(FragileFunction3<? extends R,?,? super P1,? super P2,? super P3> fragileFunction)` Convert a fragile 3-argument function which could throw an exception into non-fragile one.
    `static Procedure0` | `toRobustP0(FragileProcedure0<?> fragileProc)` Convert a fragile zero-argument procedure which could throw an exception into non-fragile one.
    `static <P> Procedure1<P>` | `toRobustP1(FragileProcedure1<?,? super P> fragileProc)` Convert a fragile one-argument procedure which could throw an exception into non-fragile one.
    `static <P1,P2> Procedure2<P1,P2>` | `toRobustP2(FragileProcedure2<?,? super P1,? super P2> fragileProc)` Convert a fragile two-argument procedure which could throw an exception into non-fragile one.
    `static <P1,P2,P3> Procedure3<P1,P2,P3>` | `toRobustP3(FragileProcedure3<?,? super P1,? super P2,? super P3> fragileProc)` Convert a fragile 3-argument procedure which could throw an exception into non-fragile one.
    `static short[]` | `toShortArray(java.util.Collection<? extends java.lang.Number> c)` Convert a collection of `Number`s to a raw array of shorts.
    `static short[]` | `toShortArray(Countable<? extends java.lang.Number> c)` Convert a countable of `Number`s to a raw array of shorts.
    `static java.util.LinkedList<java.lang.String>` | `toStringList(java.util.Enumeration<?> enumeration)` Collect an enumeration into a linked list of strings.
    `static java.util.LinkedList<java.lang.String>` | `toStringList(java.lang.Iterable<?> iterable)` Collect the elements of an iterable into a linked list.
    `static java.util.LinkedList<java.lang.String>` | `toStringList(java.util.Iterator<?> iterator)` Collect an iterator into a linked list of strings.
    `static <T1,T2> java.util.function.BiPredicate<T1,T2>` | `trueBiPredicate()` Return a bi-predicate which returns always `true`.
    `static <T> java.util.function.Predicate<T>` | `truePredicate()` Return a predicate which returns always `true`.
    `static <T> java.util.Iterator<T>` | `unmodifiable(java.util.Iterator<T> iterator)` Wrap an iterator to keep it from modifying the underlying collection.
    `static <T> java.util.ListIterator<T>` | `unmodifiable(java.util.ListIterator<T> iterator)` Wrap a list iterator to keep it from modifying the underlying collection.
    `static <T,S> java.lang.Iterable<T>` | `view(java.util.function.Function<? super S,T> mapper, S... array)` View an array as if it belongs to another iterable type.
    `static <T,S> Indexable<T>` | `view(Indexable<S> sourceIndexable, java.util.function.Function<? super S,T> mapper)` View an indexable.
    `static <T,S> java.lang.Iterable<T>` | `view(java.lang.Iterable<S> sourceIterable, java.util.function.Function<? super S,? extends T> mapper)` View an iterable Instead of `map(java.lang.Iterable, Function)` this will work transparently on the fly.
    `static <T,S> java.util.Iterator<T>` | `view(java.util.Iterator<S> sourceIterator, java.util.function.Function<? super S,? extends T> mapper)` View an iterator as if it belongs to another type.
    `static <T,S> java.util.ListIterator<T>` | `view(java.util.ListIterator<S> sourceIterator, java.util.function.Function<? super S,T> mapper)` View a list iterator as if it belongs to another type.
    `static <T,S> java.util.Collection<T>` | `viewCollection(java.util.Collection<S> collection, java.util.function.Function<? super S,T> mapper)` View a collection as if it has of another element type.
    `static <T,S> java.util.List<T>` | `viewList(java.util.List<S> list, java.util.function.Function<? super S,T> mapper)` View a list as if it has another element type.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### RELEASE_DATE

          @Deprecated
          public static final java.lang.String RELEASE_DATE

      Deprecated. Use `ModuleVersion.VERSION` instead, or `ModuleVersionService.iterator()`/`ModuleVersionService.collectServices()` for all modules
      Release of this file.

    - #### VERSION

          @Deprecated
          public static final java.lang.String VERSION

      Deprecated. use `ModuleVersion.VERSION` instead
      Version number of this file.

    - #### COMPARABLE_COMPARATOR

          @NotNull
          public static final java.util.Comparator<? extends java.lang.Comparable> COMPARABLE_COMPARATOR

      Comparator which compares Comparables in their natural order. Will throw `NullPointerException` on `null` values.

    - #### TO_STRING_COMPARATOR

          public static final java.util.Comparator<?> TO_STRING_COMPARATOR

      Comparator which compares the toString() representation. Will throw `NullPointerException` on `null` values.

    - #### TO_STRING_IGNORE_CASE_COMPARATOR

          public static final java.util.Comparator<?> TO_STRING_IGNORE_CASE_COMPARATOR

      Comparator which compares the toString() representation in case-insensitive order. Will throw `NullPointerException` on `null` values.

    - #### EMPTY_DOUBLE_ITERATOR

          public static final java.util.PrimitiveIterator.OfDouble EMPTY_DOUBLE_ITERATOR

      Empty primitve double iterator.

    - #### EMPTY_INT_ITERATOR

          public static final java.util.PrimitiveIterator.OfInt EMPTY_INT_ITERATOR

      Empty primitive int iterator.

    - #### EMPTY_LONG_ITERATOR

          public static final java.util.PrimitiveIterator.OfLong EMPTY_LONG_ITERATOR

      Empty primitive long iterator.

    - #### EMPTY_BOOLEAN_ITERATOR

          public static final PrimitiveBooleanIterator EMPTY_BOOLEAN_ITERATOR

      Empty primitive boolean iterator.

    - #### EMPTY_BYTE_ITERATOR

          public static final PrimitiveByteIterator EMPTY_BYTE_ITERATOR

      Empty primitive byte iterator.

    - #### EMPTY_SHORT_ITERATOR

          public static final PrimitiveShortIterator EMPTY_SHORT_ITERATOR

      Empty primitive short iterator.

    - #### EMPTY_CHAR_ITERATOR

          public static final PrimitiveCharIterator EMPTY_CHAR_ITERATOR

      Empty primitive char iterator.

    - #### EMPTY_FLOAT_ITERATOR

          public static final PrimitiveFloatIterator EMPTY_FLOAT_ITERATOR

      Empty primitive float iterator.

    - #### EMPTY_HASH

          public static final int EMPTY_HASH

      Hash value for empty collections.
      See Also:
        Constant Field Values

    - #### TO_STRING

          @NotNull
          public static final Function1<java.lang.String,java.lang.Object> TO_STRING

      A type converter which converts any object into its toString() representation. It is safe for `null` values.

    - #### NUMBER_TO_DOUBLE

          @NotNull
          public static final Function1<java.lang.Double,java.lang.Number> NUMBER_TO_DOUBLE

      A type converter allowing any number based type to be converted to double.

    - #### NUMBER_TO_FLOAT

          @NotNull
          public static final Function1<java.lang.Float,java.lang.Number> NUMBER_TO_FLOAT

      A type converter allowing any number based type to be converted to float.

    - #### NUMBER_TO_LONG

          @NotNull
          public static final Function1<java.lang.Long,java.lang.Number> NUMBER_TO_LONG

      A type converter allowing any number based type to be converted to long.

    - #### NUMBER_TO_INT

          @NotNull
          public static final Function1<java.lang.Integer,java.lang.Number> NUMBER_TO_INT

      A type converter allowing any number based type to be converted to integer.

    - #### NUMBER_TO_SHORT

          @NotNull
          public static final Function1<java.lang.Short,java.lang.Number> NUMBER_TO_SHORT

      A type converter allowing any number based type to be converted to short integer.

    - #### NUMBER_TO_BYTE

          @NotNull
          public static final Function1<java.lang.Byte,java.lang.Number> NUMBER_TO_BYTE

      A type converter allowing any number based type to be converted to a byte value.

    - #### STR_TO_INT

          @NotNull
          public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT

      A converter which converts strings to integer, using base 10.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_INT_BASE_16

          @NotNull
          public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_16

      A converter which converts strings to integer, using base 16.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_INT_BASE_8

          @NotNull
          public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_8

      A converter which converts strings to integer, using base 8.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_INT_BASE_2

          @NotNull
          public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_2

      A converter which converts strings to integer, using base 2.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_LONG

          @NotNull
          public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG

      A converter which converts strings to long integer, using base 10.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_LONG_BASE_16

          @NotNull
          public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_16

      A converter which converts strings to long integer, using base 16.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_LONG_BASE_8

          @NotNull
          public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_8

      A converter which converts strings to long integer, using base 8.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_LONG_BASE_2

          @NotNull
          public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_2

      A converter which converts strings to long integer, using base 2.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_SHORT

          @NotNull
          public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT

      A converter which converts strings to short integer, using base 10.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_SHORT_BASE_16

          @NotNull
          public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_16

      A converter which converts strings to short integer, using base 16.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_SHORT_BASE_8

          @NotNull
          public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_8

      A converter which converts strings to short integer, using base 8.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_SHORT_BASE_2

          @NotNull
          public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_2

      A converter which converts strings to short integer, using base 2.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_BYTE

          @NotNull
          public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE

      A converter which converts strings to byte values, using base 10.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_BYTE_BASE_16

          @NotNull
          public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_16

      A converter which converts strings to byte values, using base 16.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_BYTE_BASE_8

          @NotNull
          public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_8

      A converter which converts strings to byte values, using base 8.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_BYTE_BASE_2

          @NotNull
          public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_2

      A converter which converts strings to byte values, using base 2.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_DOUBLE

          @NotNull
          public static final FragileTypeConverter<java.lang.Double,java.lang.String> STR_TO_DOUBLE

      A converter which converts strings (in Java number format) to double values.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_FLOAT

          @NotNull
          public static final FragileTypeConverter<java.lang.Float,java.lang.String> STR_TO_FLOAT

      A converter which converts strings (in Java number format) to float values.

      It may throw a `TypeConverterException` wrapping a `NumberFormatException`

    - #### STR_TO_BOOLEAN

          @NotNull
          public static final Function1<java.lang.Boolean,java.lang.String> STR_TO_BOOLEAN

      A converter which converts strings to boolean values.

      It follows the semantics of `Boolean.valueOf(String)`, but will pass through `null` values. .

    - #### WORD_SPLIT

          public static final Function1<java.util.List<java.lang.String>,java.lang.String> WORD_SPLIT

      A converter which splits strings into words.

    - #### STR_TO_LOWER

          public static final Function1<java.lang.String,java.lang.String> STR_TO_LOWER

      A converter which changes strings to lowercase.

    - #### STR_TO_UPPER

          public static final Function1<java.lang.String,java.lang.String> STR_TO_UPPER

      A converter which changes strings to uppercase.

    - #### NOT_NULL

          public static final Predicate1<java.lang.Object> NOT_NULL

      Predicate for filtering out null objects.

  - ### Method Detail

    - #### naturalOrder

          @NotNull
           @Deprecated
          public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder(@NotNull
                                                                                                                       java.lang.Class<T> type)

      Deprecated. use `naturalOrder()` instead
      Get a comparator which sorts comparables in their natural order.
      Type Parameters:
        `T` - comparable type
      Parameters:
        `type` - comparable type class
      Returns:
        natural order comparator

    - #### naturalOrder

          @NotNull
           @Deprecated
          public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder(@NotNull
                                                                                                                       java.util.Collection<T> list)

      Deprecated. use `naturalOrder()` instead
      Get a comparator which sorts comparables in their natural order.
      Type Parameters:
        `T` - comparable type
      Parameters:
        `list` - collection with comparable type
      Returns:
        natural order comparator

    - #### naturalOrder

          @NotNull
          public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder()

      Get a comparator which sorts comparables in their natural order.
      Type Parameters:
        `T` - comparable tyoe
      Returns:
        natural order comparator

    - #### downConverter

          @NotNull
          public static <T,S extends T> Function1<T,S> downConverter()

      A converter which converts a type to a more basic type. Java can do this alone in most circumstances, so this should rarely be necessary.
      Type Parameters:
        `S` - source type which extends the target type
        `T` - target type (base type of source type)
      Returns:
        type converter converting S to T

    - #### castConverter

          @NotNull
          public static <T,S> Function1<T,S> castConverter()

      A converter which converts a type to a any other type by applying a cast. Use this converter only if you are perfectly sure that all objects passed to this converter fulfill the promise that they are of type T, If not usage of this converter will result in a `ClassCastException`.
      Type Parameters:
        `S` - source type
        `T` - target type
      Returns:
        type converter converting S to T

    - #### nullConverter

          @NotNull
          public static <T> Function1<T,T> nullConverter()

      Type converter which does no conversion. Use this converter when there is a type converter expected, but not necessary.
      Type Parameters:
        `T` - any type
      Returns:
        type converter not doing any conversion

    - #### as

          @Nullable
          public static <T> T as(@NotNull
                                           java.lang.Class<T> type,
                                           @Nullable
                                           java.lang.Object obj)

      Cast an item to a given type if possible.
      Type Parameters:
        `T` - target type
      Parameters:
        `type` - target type
        `obj` - object
      Returns:
        obj cast to target type, or `null`

    - #### mapEntryConverter

          @NotNull
          public static <KT,VT,KS,VS> Function1<java.util.Map.Entry<KT,VT>,java.util.Map.Entry<KS,VS>> mapEntryConverter(java.util.function.Function<KS,KT> keyConverter,
                                                                                                                                  java.util.function.Function<VS,VT> valueConverter)

      Type converter which converts a map entry by simultaneously applying a converter to the key and to the value.
      Type Parameters:
        `KT` - target key type
        `VT` - target value type
        `KS` - source key type
        `VS` - source value type
      Parameters:
        `keyConverter` - key converter
        `valueConverter` - value converter
      Returns:
        the converter

    - #### combine

          public static <T,I,S> Function1<T,S> combine(@NotNull
                                                       java.util.function.Function<I,T> secondStep,
                                                       @NotNull
                                                       java.util.function.Function<S,? extends I> firstStep)

      Get a combined type converter using an intermediate value.
      Type Parameters:
        `T` - target type
        `I` - intermediate type
        `S` - source type
      Parameters:
        `secondStep` - second step, converting the intermediate vale to the target value
        `firstStep` - first step, converting the source value to the intermediate value
      Returns:
        combined converter

    - #### combineEF

          public static <T,I,S> FragileTypeConverter<T,S> combineEF(@NotNull
                                                                    FragileTypeConverter<T,I> secondStep,
                                                                    @NotNull
                                                                    java.util.function.Function<S,? extends I> firstStep)

      Get a combined type converter using an intermediate value.
      Type Parameters:
        `T` - target type
        `I` - intermediate type
        `S` - source type
      Parameters:
        `secondStep` - second step, converting the intermediate vale to the target value
        `firstStep` - first step, converting the source value to the intermediate value
      Returns:
        combined converter

    - #### combineFE

          public static <T,I,S> FragileTypeConverter<T,S> combineFE(@NotNull
                                                                    java.util.function.Function<I,T> secondStep,
                                                                    @NotNull
                                                                    FragileTypeConverter<? extends I,S> firstStep)

      Get a combined type converter using an intermediate value.
      Type Parameters:
        `T` - target type
        `I` - intermediate type
        `S` - source type
      Parameters:
        `secondStep` - second step, converting the intermediate vale to the target value
        `firstStep` - first step, converting the source value to the intermediate value
      Returns:
        combined converter

    - #### combineEE

          public static <T,I,S> FragileTypeConverter<T,S> combineEE(@NotNull
                                                                    FragileTypeConverter<T,I> secondStep,
                                                                    @NotNull
                                                                    FragileTypeConverter<? extends I,S> firstStep)

      Get a combined type converter using an intermediate value.
      Type Parameters:
        `T` - target type
        `I` - intermediate type
        `S` - source type
      Parameters:
        `secondStep` - second step, converting the intermediate vale to the target value
        `firstStep` - first step, converting the source value to the intermediate value
      Returns:
        combined converter

    - #### invert

          @NotNull
          public static <T,S> TwoWayTypeConverter<T,S> invert(@NotNull
                                                                       TwoWayTypeConverter<S,T> typeConverter)

      Get an inverted two way type converter from a given one.
      Type Parameters:
        `T` - target type
        `S` - source tyoe
      Parameters:
        `typeConverter` - given type converter
      Returns:
        inverse type converter

    - #### createTwoWay

          @NotNull
          public static <T,S> TwoWayTypeConverter<T,S> createTwoWay(@NotNull
                                                                             java.util.function.Function<S,T> toConverter,
                                                                             @NotNull
                                                                             java.util.function.Function<T,S> backConverter)

      Create a two way type converter from two one way type converters.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `toConverter` - converter for normal direction (S to T)
        `backConverter` - converter for back direction (T to S)
      Returns:
        two way type converter

    - #### toRobustF0

          @NotNull
          public static <R> Function0<R> toRobustF0(@NotNull
                                                             FragileFunction0<? extends R,?> fragileFunction)

      Convert a fragile zero-argument function which could throw an exception into non-fragile one.
      Type Parameters:
        `R` - result type of incoming and outgoing function
      Parameters:
        `fragileFunction` - fragile function
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileFunction` throws its declared exception

    - #### toRobustF1

          @NotNull
          public static <R,P> Function1<R,P> toRobustF1(@NotNull
                                                                 FragileFunction1<? extends R,?,? super P> fragileFunction)

      Convert a fragile one-argument function which could throw an exception into non-fragile one.
      Type Parameters:
        `R` - result type of incoming and outgoing function
        `P` - parameter type of incoming and outgoing function
      Parameters:
        `fragileFunction` - fragile function
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileFunction` throws its declared exception

    - #### toRobustF2

          @NotNull
          public static <R,P1,P2> Function2<R,P1,P2> toRobustF2(@NotNull
                                                                         FragileFunction2<? extends R,?,? super P1,? super P2> fragileFunction)

      Convert a fragile two-argument function which could throw an exception into non-fragile one.
      Type Parameters:
        `R` - result type of incoming and outgoing function
        `P1` - first parameter type of incoming and outgoing function
        `P2` - second parameter type of incoming and outgoing function
      Parameters:
        `fragileFunction` - fragile function
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileFunction` throws its declared exception

    - #### toRobustF3

          @NotNull
          public static <R,P1,P2,P3> Function3<R,P1,P2,P3> toRobustF3(@NotNull
                                                                               FragileFunction3<? extends R,?,? super P1,? super P2,? super P3> fragileFunction)

      Convert a fragile 3-argument function which could throw an exception into non-fragile one.
      Type Parameters:
        `R` - result type of incoming and outgoing function
        `P1` - first parameter type of incoming and outgoing function
        `P2` - second parameter type of incoming and outgoing function
        `P3` - third parameter type of incoming and outgoing function
      Parameters:
        `fragileFunction` - fragile function
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileFunction` throws its declared exception

    - #### toRobustP0

          @NotNull
          public static Procedure0 toRobustP0(@NotNull
                                                       FragileProcedure0<?> fragileProc)

      Convert a fragile zero-argument procedure which could throw an exception into non-fragile one.
      Parameters:
        `fragileProc` - fragile procedure
      Returns:
        non-fragile procedure which will throw a `RuntimeException` with the wrapped original exception if `fragileProc` throws its declared exception

    - #### toRobustP1

          @NotNull
          public static <P> Procedure1<P> toRobustP1(@NotNull
                                                              FragileProcedure1<?,? super P> fragileProc)

      Convert a fragile one-argument procedure which could throw an exception into non-fragile one.
      Type Parameters:
        `P` - parameter type of incoming and outgoing procedure
      Parameters:
        `fragileProc` - fragile procedure
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileProc` throws its declared exception

    - #### toRobustP2

          @NotNull
          public static <P1,P2> Procedure2<P1,P2> toRobustP2(@NotNull
                                                                      FragileProcedure2<?,? super P1,? super P2> fragileProc)

      Convert a fragile two-argument procedure which could throw an exception into non-fragile one.
      Type Parameters:
        `P1` - first parameter type of incoming and outgoing procedure
        `P2` - second parameter type of incoming and outgoing procedure
      Parameters:
        `fragileProc` - fragile procedure
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileProc` throws its declared exception

    - #### toRobustP3

          @NotNull
          public static <P1,P2,P3> Procedure3<P1,P2,P3> toRobustP3(@NotNull
                                                                            FragileProcedure3<?,? super P1,? super P2,? super P3> fragileProc)

      Convert a fragile 3-argument procedure which could throw an exception into non-fragile one.
      Type Parameters:
        `P1` - first parameter type of incoming and outgoing procedure
        `P2` - second parameter type of incoming and outgoing procedure
        `P3` - third parameter type of incoming and outgoing procedure
      Parameters:
        `fragileProc` - fragile procedure
      Returns:
        non-fragile function which will throw a `RuntimeException` with the wrapped original exception if `fragileProc` throws its declared exception

    - #### toNonFragile

          @NotNull
          public static <T,S> CarelessTypeConverter<T,S> toNonFragile(@NotNull
                                                                               FragileTypeConverter<T,S> fragileTypeConverter)

      Make a fragile type converter appear as a standard type converter.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `fragileTypeConverter` - fragile type converter
      Returns:
        fragile type converter wrapper, returning `null` on exceptions

    - #### toNonFragile

          @NotNull
          public static <T,S> CarelessTypeConverter<T,S> toNonFragile(@NotNull
                                                                               FragileTypeConverter<T,S> fragileTypeConverter,
                                                                               @Nullable
                                                                               T defaultValue)

      Make a fragile type converter appear as a standard type converter.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `fragileTypeConverter` - fragile type converter
        `defaultValue` - default value returned when the fragile type converter throws an exception
      Returns:
        fragile type converter wrapper, returning the default value on exceptions

    - #### toFragile

          @NotNull
          public static <T,S> OverCaringTypeConverter<T,S> toFragile(@NotNull
                                                                              java.util.function.Function<S,T> typeConverter)

      Make a non-fragile type converter appear as fragile.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `typeConverter` - standard non-fragile type converter
      Returns:
        overcaring type converter

    - #### downCast

          @NotNull
          public static <T> java.lang.Iterable<T> downCast(@NotNull
                                                                    java.lang.Iterable<? extends T> iterable)

      Get a down-casted iterable.

      This allows to view any iterable as being an iterable of a base class of its generic type.

      Although casting generic types is frowned upon in general, in this special case using this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw `ClassCastException`s as the result of using this method.

      Example:

      >        public void drawShapes(Iterable<Shape> shapes) {
      >          // ...
      >        }

      >        // ...
      >        Collection<Rectangle2D> rectangles = // ...
      >        drawShapes(Types.<Shape>downCast(rectangles));

      Type Parameters:
        `T` - base type
      Parameters:
        `iterable` - iterable with extended type
      Returns:
        iterator with base type

    - #### downCast

          @NotNull
          public static <T> java.util.Iterator<T> downCast(@NotNull
                                                                    java.util.Iterator<? extends T> iterator)

      Get a down-casted iterator.

      This allows to view any iterator as being an iterator of a base class of its generic type.

      Although casting generic types is frowned upon in general, in this special case using of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw `ClassCastException`s as the result of using this method.

      Example:

      >        public void drawShapes(Iterator<Shape> shapes) {
      >          // ...
      >        }

      >        // ...
      >        Collection<Rectangle2D> rectangles = // ...
      >        drawShapes(Types.<Shape>downCast(rectangles.iterator());

      Type Parameters:
        `T` - base type
      Parameters:
        `iterator` - iterator with extended type
      Returns:
        iterable with base type

    - #### downCast

          @NotNull
          public static <T> java.util.Enumeration<T> downCast(@NotNull
                                                                       java.util.Enumeration<? extends T> enumeration)

      Get a down-casted enumeration.

      This allows to view any enumeration as being an enumeration of a base class of its generic type.

      Although casting generic types is frowned upon in general, in this special case usage of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw `ClassCastException`s as the result of using this method.

      Example:

      >        public void drawShapes(Enumeration<Shape> shapes) {
      >          // ...
      >        }

      >        // ...
      >        GVector<Rectangle2D> rectangles = // ...
      >        drawShapes(Types.<Shape>downCast(rectangles.enumeration());

      Type Parameters:
        `T` - base type
      Parameters:
        `enumeration` - enumeration with extended type
      Returns:
        enumerator with base type

    - #### downCast

          @NotNull
          public static <T,S> java.util.function.Function<S,T> downCast(@NotNull
                                                                                 java.util.function.Function<? super S,? extends T> typeConverter)

      Downcast a type converter.

      Using this method is typesafe.

      Although casting generic types is frowned upon in general, in this special case usage of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw `ClassCastException`s as the result of using this method.

      Type Parameters:
        `T` - base type of original target type
        `S` - extending type of original source type
      Parameters:
        `typeConverter` - type converter to downcast
      Returns:
        casted type converter

    - #### downCastT

          @NotNull
          public static <T,S> FragileTypeConverter<T,S> downCastT(@NotNull
                                                                           FragileTypeConverter<? extends T,? super S> typeConverter)

      Downcast a type converter.

      Using this method is typesafe.

      Type Parameters:
        `T` - base type of original target type
        `S` - extending type of original source type
      Parameters:
        `typeConverter` - type converter to downcast
      Returns:
        casted type converter

    - #### cast

          @NotNull
          public static <T> java.lang.Iterable<T> cast(@NotNull
                                                                java.lang.Iterable<?> iterable)

      Get a casted iterable.

      Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the iteration fulfill the promise that they are of type T. Otherwise a `ClassCastException` will be thrown when using the iterator if the iterable.

      In other words: you can use this method to compile a program which will fail at runtime! And that is usually a stupid idea. So you should rethink your design before using this method.

      The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

      Example:

             // we have this naked collection, but we know all its elements are Strings
             Collection foo = otherLibObject.getCollection();
             for (String str : Types.<String>cast(foo)) {
               // ...
             }

      Type Parameters:
        `T` - target type
      Parameters:
        `iterable` - iterable with any tye
      Returns:
        iterator with target type

    - #### cast

          @NotNull
          public static <T> java.util.Iterator<T> cast(@NotNull
                                                                java.util.Iterator<?> iterator)

      Get a casted iterator.

      Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the iterator fulfill the promise that they are of type T. Otherwise a `ClassCastException` will be thrown when using the iterator.

      In other words: you can use this method to compile a program which will fail at runtime! And that is usually a stupid idea. So you should rethink your design before using this method.

      The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

      See `cast(java.lang.Iterable)` for an easy to adapt example.

      Type Parameters:
        `T` - target type
      Parameters:
        `iterator` - iterator with any type
      Returns:
        iterator with target type

    - #### cast

          @NotNull
          public static <T> java.util.Enumeration<T> cast(@NotNull
                                                                   java.util.Enumeration<? extends T> enumeration)

      Get a casted enumeration.

      Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the enumeration fulfill the promise that they are of type T. Otherwise a `ClassCastException` will be thrown when using the enumeration.

      In other words: you can use this method to compile a program which will fail at runtime! And that is a stupid idea. So you should rethink your design before using this method.

      The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

      See `cast(java.lang.Iterable)` for an easy to adapt example.

      Type Parameters:
        `T` - target type
      Parameters:
        `enumeration` - enumeration with any type
      Returns:
        enumerator with target type

    - #### flatten

          @NotNull
          public static <T> java.util.LinkedList<T> flatten(@NotNull
                                                                     java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)

      Flatten a collection of collections. This will create a single linked list which contains all elements contained in the incoming collections.
      Type Parameters:
        `T` - basic type
      Parameters:
        `collectionOfCollections` - collection to flatten
      Returns:
        flattened linked list with all elements

    - #### flatten

          @NotNull
          public static <T,R extends java.util.Collection<? super T>> R flatten(@NotNull
                                                                                         R target,
                                                                                         @NotNull
                                                                                         java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)

      Flatten a collection of collections. This will create a single collection which contains all elements contained in the incoming collections.
      Type Parameters:
        `T` - basic type
        `R` - result type
      Parameters:
        `target` - target collection, where the elements are stored
        `collectionOfCollections` - collection to flatten
      Returns:
        flattened linked list with all elements

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       S[] array,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an array into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an array into a map.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an array into a map.

      This will add all mapped elements to the target collection, using the incoming values as keys pointing to the converted values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.lang.Iterable<S> iterable,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iteration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                              C target,
                                                                                              @NotNull
                                                                                              java.lang.Iterable<S> iterable,
                                                                                              @NotNull
                                                                                              java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iteration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iteration into a map.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iteration into a map.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.util.Iterator<S> iterator,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iterator into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iterator into a map.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an iterator into a map.

      This will add all mapped elements to the target collection, using the incoming values as keys pointing to the converted values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.util.Enumeration<S> enumeration,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <KT,VT,KS,VS> java.util.HashMap<KT,VT> map(@NotNull
                                                                            java.util.Map<KS,VS> source,
                                                                            @NotNull
                                                                            java.util.function.Function<java.util.Map.Entry<KS,VS>,java.util.Map.Entry<KT,VT>> typeConverter)

      Map one map into another, while allowing to discard elements on the way.

      An element is discarded if the type converter returns `null`.

      Type Parameters:
        `KT` - target map key type
        `VT` - target map value type
        `KS` - source map key type
        `VS` - source map value type
      Parameters:
        `source` - source map
        `typeConverter` - type converter converting map entries
      Returns:
        target map

    - #### map

          @NotNull
          public static <MT extends java.util.Map<KT,VT>,KT,VT,KS,VS> MT map(@NotNull
                                                                                      MT target,
                                                                                      @NotNull
                                                                                      java.util.Map<KS,VS> source,
                                                                                      @NotNull
                                                                                      java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter)

      Map one map into another, while allowing to discard elements on the way.

      An element is discarded if the type converter returns `null`.

      Type Parameters:
        `MT` - target map type
        `KT` - target map key type
        `VT` - target map value type
        `KS` - source map key type
        `VS` - source map value type
      Parameters:
        `target` - target map
        `source` - source map
        `typeConverter` - type converter converting map entries
      Returns:
        target map

    - #### mapX

          @NotNull
          public static <KT,VT,KS,VS> java.util.HashMap<KT,VT> mapX(@NotNull
                                                                             java.util.Map<KS,VS> source,
                                                                             @NotNull
                                                                             java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,java.lang.Iterable<java.util.Map.Entry<KT,VT>>> typeConverter)

      Map one map into another, while allowing to discard elements on the way.

      An element is discarded if the type converter returns `null`.

      Type Parameters:
        `KT` - target map key type
        `VT` - target map value type
        `KS` - source map key type
        `VS` - source map value type
      Parameters:
        `source` - source map
        `typeConverter` - type converter converting map entries
      Returns:
        target map

    - #### mapX

          @NotNull
          public static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT mapX(@NotNull
                                                                                                       MT target,
                                                                                                       @NotNull
                                                                                                       java.util.Map<KS,VS> source,
                                                                                                       @NotNull
                                                                                                       java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter)

      Map one map into another, allowing to discard or add elements on the way.
      Type Parameters:
        `MT` - target map type
        `KT` - target map key type
        `VT` - target map value type
        `KS` - source map key type
        `VS` - source map value type
      Parameters:
        `target` - target map
        `source` - source map
        `typeConverter` - type converter converting map entries
      Returns:
        target map

    - #### filter

          @NotNull
          public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        T[] array,
                                                                                        @NotNull
                                                                                        java.util.function.Predicate<? super T> filter)

      Filter the elements of an array into a collection.

      This will add all filtered elements to the target collection.

      Type Parameters:
        `C` - collection type
        `T` - filtered type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `filter` - filter to decide which elements are kept, when returning `true` the element is kept, otherwise it is discarded
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.lang.Iterable<T> iterable,
                                                                                        @NotNull
                                                                                        java.util.function.Predicate<? super T> checker)

      Filter the elements of an iterable into a collection.

      This will add all filtered elements to the target collection.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - filtered type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Iterator<T> iterator,
                                                                                        @NotNull
                                                                                        java.util.function.Predicate<? super T> checker)

      Filter the elements of an iterator into a collection.

      This will add all filtered elements to the target collection.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - filtered type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Enumeration<T> enumeration,
                                                                                        @NotNull
                                                                                        java.util.function.Predicate<? super T> checker)

      Filter the elements of an enumeration into a collection.

      This will add all filtered elements to the target collection.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - filtered type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <T> java.util.LinkedList<T> filter(@NotNull
                                                                    T[] array,
                                                                    @NotNull
                                                                    java.util.function.Predicate<? super T> checker)

      Filter the elements of an array into a collection.

      This will add all filtered elements to the target collection.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `array` - array providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <T> java.util.LinkedList<T> filter(@NotNull
                                                                    java.lang.Iterable<T> iterable,
                                                                    @NotNull
                                                                    java.util.function.Predicate<? super T> checker)

      Filter the elements of an iterable into a collection.

      This will add all filtered elements to the target collection.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterable` - iterable providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <T> java.util.LinkedList<T> filter(@NotNull
                                                                    java.util.Iterator<T> iterator,
                                                                    @NotNull
                                                                    java.util.function.Predicate<? super T> checker)

      Filter the elements of an iterator into a collection.

      This will add all filtered elements to the target collection.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterator` - iterator providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filter

          @NotNull
          public static <T> java.util.LinkedList<T> filter(@NotNull
                                                                    java.util.Enumeration<T> enumeration,
                                                                    @NotNull
                                                                    java.util.function.Predicate<? super T> checker)

      Filter the elements of an enumeration into a result list.
      Type Parameters:
        `T` - filtered type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        reference to target, allowing to create it directly in the call

    - #### filterOut

          public static <T> boolean filterOut(@NotNull
                                              java.lang.Iterable<T> iterable,
                                              @NotNull
                                              java.util.function.Predicate<? super T> outCheck)

      Filter a modifiable iterable inline. This removes elements with certain properties from the iterable.
      Type Parameters:
        `T` - collection element type
      Parameters:
        `iterable` - modifiable iterable expected to provide an iterator which implements the `Iterator.remove()` method
        `outCheck` - predicate which returns `true` for elements which are expected to be removed
      Returns:
        `true` if the collection was mdified
        `false` if nothing was changed
      Throws:
        `java.lang.RuntimeException` - whatever the iterator of the iterable throws when calling its remove() method

    - #### any

          public static <T> boolean any(@NotNull
                                        T[] array,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does any element in the array fulfill the predicate?

      This will check all array elements against the predicate, and return `true` on the first positive check.

      Type Parameters:
        `T` - checked type
      Parameters:
        `array` - array providing the source elements
        `checker` - value checker
      Returns:
        `true`: if any of the elements of the array matches the predicate
        `false`: if none of the elements matches or the array is empty

    - #### any

          public static <T> boolean any(@NotNull
                                        java.lang.Iterable<T> iterable,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does any element in the iterable fulfill the predicate?

      This will check all elements against the predicate, and return `true` on the first positive check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterable` - iterable providing the source elements
        `checker` - value checker
      Returns:
        `true`: if any of the elements of the array matches the predicate
        `false`: if none of the elements matches or the iterable is empty

    - #### any

          public static <T> boolean any(@NotNull
                                        java.util.Iterator<T> iterator,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does any element of the iterator fulfill the predicate?

      This will check all elements against the predicate, and return `true` on the first positive check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterator` - iterator providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        `true`: if any of the elements of the array matches the predicate
        `false`: if none of the elements matches or the iterator is empty

    - #### any

          public static <T> boolean any(@NotNull
                                        java.util.Enumeration<T> enumeration,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does any element of the enumeration fulfill the predicate?

      This will check all elements against the predicate, and return `true` on the first positive check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        `true`: if any of the elements of the array matches the predicate
        `false`: if none of the elements matches or the enumeration is empty

    - #### all

          public static <T> boolean all(@NotNull
                                        T[] array,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does every element in the array fulfill the predicate?

      This will check all array elements against the predicate, and return `false` on the first negative check.

      Type Parameters:
        `T` - checked type
      Parameters:
        `array` - array providing the source elements
        `checker` - value checker
      Returns:
        `true`: if all of the elements of the array match the predicate or the array is empty
        `false`: if any of the elements does not match

    - #### all

          public static <T> boolean all(@NotNull
                                        java.lang.Iterable<T> iterable,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does every element in the iterable fulfill the predicate?

      This will check all elements against the predicate, and return `false` on the first negative check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterable` - iterable providing the source elements
        `checker` - value checker
      Returns:
        `true`: if all of the elements of the iterable match the predicate or the iterable is empty
        `false`: if any of the elements does not match

    - #### all

          public static <T> boolean all(@NotNull
                                        java.util.Iterator<T> iterator,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does every element of the iterator fulfill the predicate?

      This will check all elements against the predicate, and return `false` on the first negative check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `iterator` - iterator providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        `true`: if all of the elements of the iterator match the predicate or the iterator is empty
        `false`: if any of the elements does not match

    - #### all

          public static <T> boolean all(@NotNull
                                        java.util.Enumeration<T> enumeration,
                                        @NotNull
                                        java.util.function.Predicate<? super T> checker)

      Does every element of the enumeration fulfill the predicate?

      This will check all elements against the predicate, and return `false` on the first negative check.

      Type Parameters:
        `T` - filtered type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `checker` - value checker to decide which elements are kept
      Returns:
        `true`: if all of the elements of the enumeration match the predicate or the enumeration is empty
        `false`: if any of the elements does not match

    - #### first

          @Nullable
          public static <T> T first(@NotNull
                                              java.lang.Iterable<T> iterable,
                                              @NotNull
                                              java.util.function.Predicate<? super T> checker)

      Get the first element which fulfills a check.
      Type Parameters:
        `T` - element type
      Parameters:
        `iterable` - iterable
        `checker` - value checker to decide which elements fit
      Returns:
        first matching element of `null`

    - #### last

          @Nullable
          public static <T> T last(@NotNull
                                             java.lang.Iterable<T> iterable,
                                             @NotNull
                                             java.util.function.Predicate<? super T> checker)

      Get the last element which fulfills a check.
      Type Parameters:
        `T` - element type
      Parameters:
        `iterable` - iterable
        `checker` - value checker to decide which elements fit
      Returns:
        last matching element of `null`

    - #### last

          @Nullable
          public static <T> T last(@NotNull
                                             java.util.List<T> list,
                                             @NotNull
                                             java.util.function.Predicate<? super T> checker,
                                             int startIndex)

      Get the last element which fulfills a check.
      Type Parameters:
        `T` - element type
      Parameters:
        `list` - list to check
        `checker` - value checker to decide which elements fit
        `startIndex` - start index of search
      Returns:
        last matching element of `null`

    - #### foldLeft

          public static <V,T> V foldLeft(@NotNull
                                         T[] array,
                                         V initialValue,
                                         @NotNull
                                         java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do left-associative folding of an array.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Eg to calculate the integer sum of an array of Numbers, you can use the following code

      >       Number[] array = { 1, Math.PI, 9L };
      >       double result = Types.foldLeft(array, 0.0,
      >                                     new Function2<Double, Double, Number>() {
      >                                        public Double apply(Double arg1, Number arg2) {
      >                                          return arg1 + arg2.doubleValue();
      >                                        }
      >                                     });

      `result` will have a value of 13.14... after the call.
      Type Parameters:
        `V` - accumulated value type
        `T` - array type
      Parameters:
        `array` - array which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldLeft

          public static <V,T> V foldLeft(@NotNull
                                         java.lang.Iterable<T> iterable,
                                         V initialValue,
                                         @NotNull
                                         java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do left-associative folding of an iterable.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Eg to calculate the integer sum of an array of Numbers, you can use the following code

      >       Collection<Number> numbers = Types.<Number>asList(1, Math.PI, 9L);
      >       double result = Types.foldLeft(numbers, 0.0,
      >                                     new Function2<Double, Double, Number>() {
      >                                        public Double apply(Double arg1, Number arg2) {
      >                                          return arg1 + arg2.doubleValue();
      >                                        }
      >                                     });

      `result` will have a value of 13.14... after the call.
      Type Parameters:
        `V` - accumulated value type
        `T` - iterable type
      Parameters:
        `iterable` - iterable which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldLeft

          public static <V,T> V foldLeft(@NotNull
                                         java.util.Iterator<T> iterator,
                                         V initialValue,
                                         @NotNull
                                         java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do left-associative folding of an iterator.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      See `foldLeft(Iterable, Object, BiFunction)` for a code example.

      Type Parameters:
        `V` - accumulated value type
        `T` - iterable type
      Parameters:
        `iterator` - iterator which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldLeft

          public static <V,T> V foldLeft(@NotNull
                                         java.util.Enumeration<T> enumeration,
                                         V initialValue,
                                         @NotNull
                                         java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do left-associative folding of an enumeration.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      See `foldLeft(Iterable, Object, BiFunction)` for a code example.

      Type Parameters:
        `V` - accumulated value type
        `T` - iterable type
      Parameters:
        `enumeration` - enumeration which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          T[] array,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of an array.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(Object[], Object, BiFunction)`.

      Type Parameters:
        `V` - accumulated value type
        `T` - array type
      Parameters:
        `array` - array which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          java.lang.Iterable<T> iterable,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of an iterable.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(Object[], Object, BiFunction)`, especially as the implementation for iterables is requiring an intermediate copy. If you really find a use for right-folding try to use the `foldRight method working on a list`, as it avoids the copy mentioned above.

      Type Parameters:
        `V` - accumulated value type
        `T` - iterable type
      Parameters:
        `iterable` - iterable which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          java.util.Iterator<T> iterator,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of an iteration.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(Iterable, Object, BiFunction)`, especially as the implementation for iteration is requiring an intermediate copy. If you really find a use for right-folding you should try to use the `foldRight method working on a list`, as it avoids the copy mentioned above.

      Type Parameters:
        `V` - accumulated value type
        `T` - iterator type
      Parameters:
        `iterator` - iterator which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          java.util.Enumeration<T> enumeration,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of an enumeration.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(java.util.Iterator, Object, BiFunction)`, especially as the implementation for iteration is requiring an intermediate copy. If you really find a use for right-folding you should try to use the `foldRight method working on a list`, as it avoids the copy mentioned above.

      Type Parameters:
        `V` - accumulated value type
        `T` - enumeration type
      Parameters:
        `enumeration` - enumeration which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          java.util.List<T> list,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of a list.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(java.util.Enumeration, Object, BiFunction)`, especially as the implementation for iteration is requiring an intermediate copy.

      Type Parameters:
        `V` - accumulated value type
        `T` - list type
      Parameters:
        `list` - list which elements are folded together
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### foldRight

          public static <V,T> V foldRight(@NotNull
                                          java.util.ListIterator<T> reverseIterator,
                                          V initialValue,
                                          @NotNull
                                          java.util.function.BiFunction<? super V,? super T,? extends V> folder)

      Do right-associative folding of a list iterator using it in reverse direction.

      Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

      Currently I have no useful example where right-folding in Java is making sense, so you should prefer `foldLeft(Iterable, Object, BiFunction)`, especially as the implementation for iteration is requiring an intermediate copy.

      Type Parameters:
        `V` - accumulated value type
        `T` - list type
      Parameters:
        `reverseIterator` - iterator which is traverse in reverse direction
        `initialValue` - start value
        `folder` - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination
      Returns:
        accumulated value

    - #### mapX

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        S[] array,
                                                                                        @NotNull
                                                                                        java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Add the mapped elements of an array into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapX

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.lang.Iterable<S> iterable,
                                                                                        @NotNull
                                                                                        java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Add the mapped elements of an iteration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapX

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Iterator<S> iterator,
                                                                                        @NotNull
                                                                                        java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Add the mapped elements of an iterator into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapX

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Enumeration<S> enumeration,
                                                                                        @NotNull
                                                                                        java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterable.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                                  java.util.Collection<S> collection,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of a collection.

      This method has the advantage that the size of the collection is known, so an `ArrayList` is used for the resulting collection.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source target
      Parameters:
        `collection` - collection to be mapped
        `typeConverter` - type converter doing the mapping
      Returns:
        linked list with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                                  Countable<S> countable,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of a countable.

      This method has the advantage that the size of the countable is known, so an `ArrayList` is used for the resulting collection.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source target
      Parameters:
        `countable` - collection to be mapped
        `typeConverter` - type converter doing the mapping
      Returns:
        linked list with mapping results

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterable as a hash map..

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapM(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterable as a hash map..

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapR(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                                  S[] array,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an array.

      See `map(java.util.Collection, Object[], Function)` for a method which allows to define the result collection.

      See `map(Object[], Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   S[] array,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an array as a map.

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Object[], Function)` for a method which allows to define the result collection.

      See `mapM(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   S[] array,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an array as a map.

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Object[], Function)` for a method which allows to define the result collection.

      See `mapR(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterator.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      See `map(Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      See Also:
        `view(java.util.Iterator, Function)`

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterator as a map.

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Iterable, Function)` for a method which allows to define the result collection.

      See `mapM(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Get the mapped elements of an iterator as a map.

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Iterable, Function)` for a method which allows to define the result collection.

      See `mapR(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a collection.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter)

      Add the mapped elements of an enumeration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapX

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                                    java.lang.Iterable<S> iterable,
                                                                    @NotNull
                                                                    java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Get the mapped elements of an iterable.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapX

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                                    S[] array,
                                                                    @NotNull
                                                                    java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Get the mapped elements of an array.

      See `map(java.util.Collection, Object[], Function)` for a method which allows to define the result collection.

      See `map(Object[], Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapX

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                                    java.util.Iterator<S> iterator,
                                                                    @NotNull
                                                                    java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Get the mapped elements of an iterator.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      See `map(Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results

    - #### mapX

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                                    java.util.Enumeration<S> enumeration,
                                                                    @NotNull
                                                                    java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

      Add the mapped elements of an enumeration into a collection.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       S[] array,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter,
                                                                                       @Nullable
                                                                                       T deleteMark)

      Add the mapped elements of an array into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an array into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an array into a map.

      The incoming values will become keys, pointing to the associated mapped values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.lang.Iterable<S> iterable,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter,
                                                                                       @Nullable
                                                                                       T deleteMark)

      Add the mapped elements of an iteration into a collection.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                              C target,
                                                                                              @NotNull
                                                                                              java.lang.Iterable<S> iterable,
                                                                                              @NotNull
                                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                                              @Nullable
                                                                                              T deleteMark)

      Add the mapped elements of an iteration to a consumer.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - consumer applied to each mapped element
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an iteration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an iteration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.util.Iterator<S> iterator,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter,
                                                                                       @Nullable
                                                                                       T deleteMark)

      Add the mapped elements of an iterator into a collection.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                              C target,
                                                                                              @NotNull
                                                                                              java.util.Iterator<S> iterator,
                                                                                              @NotNull
                                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                                              @Nullable
                                                                                              T deleteMark)

      Add the mapped elements of an iterator to a consumer.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - consumer to which all mapped elements are forwarded
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an iterator into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an iterator into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                                       C target,
                                                                                       @NotNull
                                                                                       java.util.Enumeration<S> enumeration,
                                                                                       @NotNull
                                                                                       java.util.function.Function<? super S,T> typeConverter,
                                                                                       @Nullable
                                                                                       T deleteMark)

      Add the mapped elements of an enumeration into a collection.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an enumeration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapR

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                           M target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           java.util.function.Function<? super S,T> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)

      Add the mapped elements of an enumeration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   S[] array,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an array.

      This method allows to discard elements during the mapping.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   S[] array,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an array as a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   S[] array,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an array as a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an iterable.

      This method allows to discard elements during the mapping.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979", "foobar" };
      >         List<Double> result = Types.map(Types.asList(values),
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             try {
      >                                               return Double.parseDouble(object);
      >                                             } catch (NumberFormatException x) {
      >                                               return null; // delete mark, compare last parameter
      >                                             }
      >                                           }
      >                                         },
      >                                         null);

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an iterable to a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.lang.Iterable<S> iterable,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Get the mapped elements of an iterable to a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an iterator into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an iterator into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.util.Iterator<S> iterator,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an iterator into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results

    - #### map

          @NotNull
          public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an enumeration into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call

    - #### mapM

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an enumeration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        result map

    - #### mapR

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                                   java.util.Enumeration<S> enumeration,
                                                                   @NotNull
                                                                   java.util.function.Function<? super S,T> typeConverter,
                                                                   @Nullable
                                                                   T deleteMark)

      Add the mapped elements of an enumeration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        result map

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     S[] array,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Object[], FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an array into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Example:

      >         // convert an array of strings containing double values into a collection of doubles
      >         String[] values = { "1.2", "-7.07", "3.14250255358979" };
      >         List<Double> result = Types.map(new ArrayList<Double>(values.length),
      >                                         values,
      >                                         new Function1<Double, String>() {
      >                                           public Double convert(String object) {
      >                                             return Double.parseDouble(object);
      >                                           }
      >                                         });

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    S[] array,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an array into a collection by using a mapper function which might throw a checked exception.
      Type Parameters:
        `C` - type of returned collection
        `T` - target (mapped) element type
        `S` - source element type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `mapper` - mapper function converting the source elements into the target elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - mapper exception
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            S[] array,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an array into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            S[] array,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an array into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.lang.Iterable<S> iterable,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Iterable, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an iteration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.lang.Iterable<S> iterable,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an iterable into a collection by using a mapper function which might throw a checked exception.
      Type Parameters:
        `C` - type of returned collection
        `T` - target (mapped) element type
        `S` - source element type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `mapper` - mapper function converting the source elements into the target elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - mapper exception
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.lang.Iterable<S> iterable,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iteration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.lang.Iterable<S> iterable,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iteration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.util.Iterator<S> iterator,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Iterator, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an iterator into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.util.Iterator<S> iterator,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an iterator into a collection by using a mapper function which might throw a checked exception.
      Type Parameters:
        `C` - type of returned collection
        `T` - target (mapped) element type
        `S` - source element type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `mapper` - mapper function converting the source elements into the target elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - mapper exception
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Iterator<S> iterator,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iterator to a map.

      The converted values will become keys, pointing to the associated incoming values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Iterator<S> iterator,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iterator to a map.

      The incoming values will become keys, pointing to the associated converted values.

      This will add all mapped elements to the target map. See `mapR(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.util.Enumeration<S> enumeration,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Enumeration, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.util.Enumeration<S> enumeration,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an enumeration into a collection by using a mapper function which might throw a checked exception.
      Type Parameters:
        `C` - type of returned collection
        `T` - target (mapped) element type
        `S` - source element type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `mapper` - mapper function converting the source elements into the target elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - mapper exception
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Enumeration<S> enumeration,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The converted values will become keys, pointing to the associated incoming values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Enumeration<S> enumeration,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter)
                                                                                     throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The incoming values will become keys, pointing to the associated converted values.

      This will add all mapped elements to the target map. See `mapM(java.util.Map, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Iterable, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Get the mapped elements of an iterable.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.lang.Iterable<S> iterable,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an iterable while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `iterable` - iterable providing the source elements
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        linked list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.lang.Iterable<S> iterable,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an iterable as a map.

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapM(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.lang.Iterable<S> iterable,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an iterable as a map.

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapR(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Object[], FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Get the mapped elements of an array.

      See `map(java.util.Collection, Object[], Function)` for a method which allows to define the result collection.

      See `map(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                                       S[] array,
                                                                                                       @NotNull
                                                                                                       FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                throws E extends java.lang.Exception

      Get the mapped elements of an array while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `array` - array providing the source elements
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        array list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                                       java.util.Collection<S> collection,
                                                                                                       @NotNull
                                                                                                       FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                throws E extends java.lang.Exception

      Get the mapped elements of a collection while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `collection` - collection providing the source elements
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        array list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                                       Countable<S> countable,
                                                                                                       @NotNull
                                                                                                       FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                throws E extends java.lang.Exception

      Get the mapped elements of an array while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `countable` - countable providing the source elements
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        array list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.util.Iterator<S> iterator,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an iterator while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `iterator` - iterator providing the source elements, consumed after the call
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        linked list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.util.Enumeration<S> enumeration,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an enumeration while using a mapper which might throw a checked exception.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `enumeration` - enumeration providing the source elements, consumed after the call
        `mapper` - mapper converting the source elements into the target elements
      Returns:
        linked list with mapping results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    S[] array,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an array as a map.

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Object[], Function)` for a method which allows to define the result map.

      See `mapM(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    S[] array,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an array as a map.

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Object[], Function)` for a method which allows to define the result map.

      See `mapR(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Iterator, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Get the mapped elements of an iterator.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      See `map(Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.util.Iterator<S> iterator,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an iterator as a map.

      The converted values will become keys, pointing to the associated incoming values.

      See `mapM(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapM(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.util.Iterator<S> iterator,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Get the mapped elements of an iterator as a map.

      The incoming values will become keys, pointing to the associated converted values.

      See `mapR(java.util.Map, Iterable, Function)` for a method which allows to define the result map.

      See `mapR(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Enumeration, FragileFunction1)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an enumeration into a collection.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with converted elements
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.util.Enumeration<S> enumeration,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Add the mapped elements of an enumeration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with converted elements
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.util.Enumeration<S> enumeration,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter)
                                                             throws TypeConverterException

      Add the mapped elements of an enumeration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        map with converted elements
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         S[] array,
                                                                                         @NotNull
                                                                                         FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                                  throws TypeConverterException

      Add the mapped elements of an array into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.lang.Iterable<S> iterable,
                                                                                         @NotNull
                                                                                         FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                                  throws TypeConverterException

      Add the mapped elements of an iteration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.util.Iterator<S> iterator,
                                                                                         @NotNull
                                                                                         FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                                  throws TypeConverterException

      Add the mapped elements of an iterator into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.util.Enumeration<S> enumeration,
                                                                                         @NotNull
                                                                                         FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                                  throws TypeConverterException

      Add the mapped elements of an enumeration into a collection.

      This will add all mapped elements to the target collection. See `map(java.util.Collection, Iterable, Function, Object)` for a method which allows to discard elements.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      See `map(java.util.Collection, Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                                     java.lang.Iterable<S> iterable,
                                                                     @NotNull
                                                                     FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                              throws TypeConverterException

      Get the mapped elements of an iterable.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                                     S[] array,
                                                                     @NotNull
                                                                     FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                              throws TypeConverterException

      Get the mapped elements of an array.

      See `map(java.util.Collection, Object[], Function)` for a method which allows to define the result collection.

      See `map(Object[], Function, Object)` for a method which allows to discard elements.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                                     java.util.Iterator<S> iterator,
                                                                     @NotNull
                                                                     FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                              throws TypeConverterException

      Get the mapped elements of an iterator.

      See `map(java.util.Collection, Iterable, Function)` for a method which allows to define the result collection.

      See `map(Iterable, Function, Object)` for a method which allows to discard elements.

      See `map(Iterable, Function)` for an easy to adapt example.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapXE

          @NotNull
          public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                                     java.util.Enumeration<S> enumeration,
                                                                     @NotNull
                                                                     FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                              throws TypeConverterException

      Add the mapped elements of an enumeration into a collection.
      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     S[] array,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter,
                                                                                                     @Nullable
                                                                                                     T deleteMark)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Object[], FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an array into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    S[] array,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                                    @Nullable
                                                                                                                    T deleteMark)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an array into a collection while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `array` - array providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            S[] array,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an array into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            S[] array,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an array into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.lang.Iterable<S> iterable,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter,
                                                                                                     @Nullable
                                                                                                     T deleteMark)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Iterable, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an iteration into a collection.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.lang.Iterable<S> iterable,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                                    @Nullable
                                                                                                                    T deleteMark)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an iterable into a collection while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterable` - iterable providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.lang.Iterable<S> iterable,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iteration into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (converted) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.lang.Iterable<S> iterable,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iteration into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that target and iterable are not allowed to be the same object, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (converted) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.util.Iterator<S> iterator,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter,
                                                                                                     @Nullable
                                                                                                     T deleteMark)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Iterator, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an iterator into a collection.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.util.Iterator<S> iterator,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                                    @Nullable
                                                                                                                    T deleteMark)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an iterator into a collection while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `iterator` - iterator providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Iterator<S> iterator,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iterator into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Iterator<S> iterator,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an iterator into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                                     C target,
                                                                                                     @NotNull
                                                                                                     java.util.Enumeration<S> enumeration,
                                                                                                     @NotNull
                                                                                                     FragileTypeConverter<T,? super S> typeConverter,
                                                                                                     @Nullable
                                                                                                     T deleteMark)
                                                                                              throws TypeConverterException

      Deprecated. use `mapFragile(Collection, Enumeration, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an enumeration into a collection.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                                    C target,
                                                                                                                    @NotNull
                                                                                                                    java.util.Enumeration<S> enumeration,
                                                                                                                    @NotNull
                                                                                                                    FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                                    @Nullable
                                                                                                                    T deleteMark)
                                                                                                             throws E extends java.lang.Exception

      Add the mapped elements of an enumeration into a collection while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `C` - collection type
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `target` - collection where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Enumeration<S> enumeration,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                            M target,
                                                                                            @NotNull
                                                                                            java.util.Enumeration<S> enumeration,
                                                                                            @NotNull
                                                                                            FragileTypeConverter<T,? super S> typeConverter,
                                                                                            @Nullable
                                                                                            T deleteMark)
                                                                                     throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a `ConcurrentModificationException`, or another exception because you are running into an endless loop.

      Type Parameters:
        `M` - map type
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `target` - map where the mapped elements are added
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Object[], FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Get the mapped elements of an array.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                                       S[] array,
                                                                                                       @NotNull
                                                                                                       FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                       @Nullable
                                                                                                       T deleteMark)
                                                                                                throws E extends java.lang.Exception

      Get the mapped elements of an array while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `array` - array providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        reference to target, allowing to create it directly in the call
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    S[] array,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Get the mapped elements of an array as a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    S[] array,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Get the mapped elements of an array as a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `array` - array providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Iterable, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Get the mapped elements of an iterable.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.lang.Iterable<S> iterable,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                        @Nullable
                                                                                                        T deleteMark)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an iterable while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `iterable` - iterable providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        mapped and filtered results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.lang.Iterable<S> iterable,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Get the mapped elements of an iterable as a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.lang.Iterable<S> iterable,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Get the mapped elements of an iterable as a map.

      The incoming values will become keys, pointing to the associated convereted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterable` - iterable providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Iterator, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an iterator into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.util.Iterator<S> iterator,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                        @Nullable
                                                                                                        T deleteMark)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an iterator while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `iterator` - iterator providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        mapped and filtered results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.util.Iterator<S> iterator,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Add the mapped elements of an iterator into a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.util.Iterator<S> iterator,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Add the mapped elements of an iterator into a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `iterator` - iterator providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapE

          @NotNull
           @Deprecated
          public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 FragileTypeConverter<T,? super S> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)
                                                                          throws TypeConverterException

      Deprecated. use `mapFragile(Enumeration, FragileFunction1, Object)` instead which does not require handling a `TypeConverterException`
      Add the mapped elements of an enumeration into a collection.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        linked list with mapped elements
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapFragile

          @NotNull
          public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                                        java.util.Enumeration<S> enumeration,
                                                                                                        @NotNull
                                                                                                        FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                        @Nullable
                                                                                                        T deleteMark)
                                                                                                 throws E extends java.lang.Exception

      Get the mapped elements of an enumeration while using a mapper which might throw an exception.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
        `E` - exception type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `mapper` - fragile mapper for converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        mapped and filtered results
      Throws:
        `E` - if the mapper throws
        `E extends java.lang.Exception`

    - #### mapME

          @NotNull
          public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                                    java.util.Enumeration<S> enumeration,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The converted values will become keys, pointing to the associated incoming values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### mapRE

          @NotNull
          public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                                    java.util.Enumeration<S> enumeration,
                                                                    @NotNull
                                                                    FragileTypeConverter<T,? super S> typeConverter,
                                                                    @Nullable
                                                                    T deleteMark)
                                                             throws TypeConverterException

      Add the mapped elements of an enumeration to a map.

      The incoming values will become keys, pointing to the associated converted values.

      This method allows to discard elements during the mapping.

      Type Parameters:
        `T` - target (mapped) type
        `S` - source type
      Parameters:
        `enumeration` - enumeration providing the source elements
        `typeConverter` - type converter converting the source elements into the mapped elements
        `deleteMark` - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often `null` is a useful choice, only in cases where the target collection may contain `null` values and the type converter may produce them another mark is necessary.
      Returns:
        map with mapping results
      Throws:
        `TypeConverterException` - if the conversion fails with an exception, the thrown exception will provide this original exception as `TypeConverterException.getException()`

    - #### forEach

          public static <T> void forEach(@NotNull
                                         T[] array,
                                         @NotNull
                                         LoopItemHandler<? super T> handler)

      Call a handler for each item in an array.
      Type Parameters:
        `T` - item type
      Parameters:
        `array` - array to loop over
        `handler` - item handler which is called for each item

    - #### forEach

          public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                                       T[] array,
                                                                       @NotNull
                                                                       FragileLoopItemHandler<? super T,E> handler)
                                                                throws E extends java.lang.Exception

      Call a handler for each item in an array.
      Type Parameters:
        `T` - item type
        `E` - exception type
      Parameters:
        `array` - array to loop over
        `handler` - item handler which is called for each item
      Throws:
        `E` - exception thrown by handler
        `E extends java.lang.Exception`

    - #### forEach

          public static <T> void forEach(@NotNull
                                         java.lang.Iterable<T> iterable,
                                         @NotNull
                                         LoopItemHandler<? super T> handler)

      Call a handler for each item in an iterable.
      Type Parameters:
        `T` - item type
      Parameters:
        `iterable` - iterable to loop over
        `handler` - item handler which is called for each item

    - #### forEach

          public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                                       java.lang.Iterable<T> iterable,
                                                                       @NotNull
                                                                       FragileLoopItemHandler<? super T,E> handler)
                                                                throws E extends java.lang.Exception

      Call a handler for each item in an iterable.
      Type Parameters:
        `T` - item type
        `E` - exception thrown by handler
      Parameters:
        `iterable` - iterable to loop over
        `handler` - item handler which is called for each item
      Throws:
        `E` - exception thrown by handler
        `E extends java.lang.Exception`

    - #### forEach

          public static <T> void forEach(@NotNull
                                         java.util.Iterator<T> iterator,
                                         @NotNull
                                         LoopItemHandler<? super T> handler)

      Call a handler for each item in an iterator.
      Type Parameters:
        `T` - item type
      Parameters:
        `iterator` - iterator to loop over
        `handler` - item handler which is called for each item

    - #### forEach

          public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                                       java.util.Iterator<T> iterator,
                                                                       @NotNull
                                                                       FragileLoopItemHandler<? super T,E> handler)
                                                                throws E extends java.lang.Exception

      Call a handler for each item in an iterator
      Type Parameters:
        `T` - item type
        `E` - exception thrown by handler
      Parameters:
        `iterator` - iterator to loop over
        `handler` - item handler which is called for each item
      Throws:
        `E` - exception thrown by handler
        `E extends java.lang.Exception`

    - #### forEach

          public static <T> void forEach(@NotNull
                                         java.util.Enumeration<T> enumeration,
                                         @NotNull
                                         LoopItemHandler<? super T> handler)

      Call a handler for each item in an enumeration.
      Type Parameters:
        `T` - item type
      Parameters:
        `enumeration` - enumeration to loop over
        `handler` - item handler which is called for each item

    - #### forEach

          public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                                       java.util.Enumeration<T> enumeration,
                                                                       @NotNull
                                                                       FragileLoopItemHandler<? super T,E> handler)
                                                                throws E extends java.lang.Exception

      Call a handler for each item in an enumeration
      Type Parameters:
        `T` - item type
        `E` - exception thrown by handler
      Parameters:
        `enumeration` - enumeration to loop over
        `handler` - item handler which is called for each item
      Throws:
        `E` - exception thrown by handler
        `E extends java.lang.Exception`

    - #### forEachFragile

          public static <T,E extends java.lang.Exception> void forEachFragile(@NotNull
                                                                              java.lang.Iterable<T> iterable,
                                                                              @NotNull
                                                                              FragileProcedure1<E,? super T> consumer)
                                                                       throws E extends java.lang.Exception

      Foreach implementation which can be used with consumers which might throw a checked exception. Use this instead of `Iterable.forEach(Consumer)` when the consumer is defined with a checked exception.
      Type Parameters:
        `T` - element type
        `E` - exception type
      Parameters:
        `iterable` - iterable to iterate over
        `consumer` - consumer called for each iterated element
      Throws:
        `E` - forwarded exception of the consumer
        `E extends java.lang.Exception`

    - #### forEachRemainingFragile

          public static <T,E extends java.lang.Exception> void forEachRemainingFragile(@NotNull
                                                                                       java.util.Iterator<T> iterator,
                                                                                       @NotNull
                                                                                       FragileProcedure1<E,? super T> consumer)
                                                                                throws E extends java.lang.Exception

      Foreach remaining implementation which can be used with consumers which might throw a checked exception. Use this instead of `Iterator.forEachRemaining(Consumer)` when the consumer is defined with a checked exception.
      Type Parameters:
        `T` - element type
        `E` - exception type
      Parameters:
        `iterator` - iterator for which all remaining elements are consumed
        `consumer` - consumer called for each remaining element
      Throws:
        `E` - forwarded exception of the consumer
        `E extends java.lang.Exception`

    - #### toLoopItemHandler

          @NotNull
          public static <T,E extends java.lang.Exception,L extends FragileLoopItemHandler<T,E>> CarelessLoopItemHandler<T,E,L> toLoopItemHandler(L handler)

      Wrap a careful loop item handler as a simple loop item handler.
      Type Parameters:
        `T` - item type
        `E` - exception type
        `L` - careful loop item handler type
      Parameters:
        `handler` - handler to wrap
      Returns:
        careless loop item handler wrapper

    - #### asList

          @NotNull
           @SafeVarargs
          public static <T> java.util.List<T> asList(@NotNull
                                                                            T... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list returned from this method, so the safest use is as a temporary object.

      >         public void method(Collection<Double> input) {
      >           // ...
      >         }

      >         // ...
      >         method(Types.asList(0, 7.1, -42, Math.PI));

      Type Parameters:
        `T` - element type of array and list
      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array

    - #### asList

          @NotNull
          public static <T> java.util.List<T> asList(@NotNull
                                                              T[] array,
                                                              int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Type Parameters:
        `T` - element type of array and list
      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### asList

          @NotNull
          public static <T> java.util.List<T> asList(@NotNull
                                                              T[] array,
                                                              int start,
                                                              int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Type Parameters:
        `T` - element type of array and list
      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toBooleanArray

          @NotNull
          public static boolean[] toBooleanArray(@NotNull
                                                          java.util.Collection<java.lang.Boolean> c)

      Convert a collection of `Boolean`s to a raw array of booleans.
      Parameters:
        `c` - collection of Booleans
      Returns:
        array of boolean
      See Also:
        `BooleanIndexable.viewList(List)`

    - #### toBooleanArray

          public static boolean[] toBooleanArray(@NotNull
                                                 Countable<java.lang.Boolean> c)

      Convert a countable of `Boolean`s to a raw array of booleans.
      Parameters:
        `c` - collection of Booleans
      Returns:
        array of boolean

    - #### toList

          @NotNull
          public static <T> java.util.LinkedList<T> toList(@NotNull
                                                                    java.util.Enumeration<T> enumeration)

      Collect an enumeration into a linked list. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.
      Type Parameters:
        `T` - type of enumeration and result list elements
      Parameters:
        `enumeration` - enumeration to convert
      Returns:
        linked list with all elements of the enumeration
      See Also:
        `addAll(Collection, Enumeration)`

    - #### toList

          @NotNull
          public static <T> java.util.LinkedList<T> toList(@NotNull
                                                                    java.util.Iterator<T> iterator)

      Collect an iterator into a linked list. This will propagate over the complete iterator, so it can no longer be iterated over after calling this method.
      Type Parameters:
        `T` - type of iterator and result list elements
      Parameters:
        `iterator` - iterator to convert
      Returns:
        linked list with all elements of the iterator
      See Also:
        `addAll(Collection, Iterator)`

    - #### toList

          @NotNull
          public static <T> java.util.LinkedList<T> toList(@NotNull
                                                                    java.lang.Iterable<T> iterable)

      Collect the elements of an iterable into a linked list.
      Type Parameters:
        `T` - type of iterable and result list elements
      Parameters:
        `iterable` - iterable to convert
      Returns:
        list with all elements of the iterable
      See Also:
        `addAll(Collection, Iterable)`

    - #### toStringList

          @NotNull
          public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                                     java.util.Enumeration<?> enumeration)

      Collect an enumeration into a linked list of strings. This will propagate over the complete enumeration and call @link`Object.toString()`, on its elements, so it can no longer be enumerated after calling this method.
      Parameters:
        `enumeration` - enumeration to convert
      Returns:
        linked list with all stringified elements of the enumeration

    - #### toStringList

          @NotNull
          public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                                     java.util.Iterator<?> iterator)

      Collect an iterator into a linked list of strings. This will propagate over the complete iterator and call @link`Object.toString()`, on its elements, so it can no longer be iterated over after calling this method.
      Parameters:
        `iterator` - iterator to convert
      Returns:
        linked list with all stringified elements of the iterator

    - #### toStringList

          @NotNull
          public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                                     java.lang.Iterable<?> iterable)

      Collect the elements of an iterable into a linked list. This will propagate over the complete iterable and call @link`Object.toString()` on its elements
      Parameters:
        `iterable` - iterable to convert
      Returns:
        list with all stringified elements of the iterable

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                          boolean... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      >         public void method(Collection<Double> input) {
      >           // ...
      >         }

      >         // ...
      >         method(Types.toList(0, 7.1, -42, Math.PI));

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                          boolean[] array,
                                                                          int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                          boolean[] array,
                                                                          int start,
                                                                          int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toByteArray

          @NotNull
          public static byte[] toByteArray(@NotNull
                                                    java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of bytes.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of bytes
      See Also:
        `ByteIndexable.viewList(List)`

    - #### toByteArray

          @NotNull
          public static byte[] toByteArray(@NotNull
                                                    Countable<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of bytes.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of bytes

    - #### toByteArray

          public static byte[] toByteArray(int... bytes)

      Convert a number of bytes into a byte array. This is a convenience method allowing to use integer values.
      Parameters:
        `bytes` - values which will be converted into bytes
      Returns:
        byte array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Byte> toList(@NotNull
                                                                       byte... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Byte> toList(@NotNull
                                                                       byte[] array,
                                                                       int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Byte> toList(@NotNull
                                                                       byte[] array,
                                                                       int start,
                                                                       int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toShortArray

          @NotNull
          public static short[] toShortArray(@NotNull
                                                      java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of shorts.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of shorts
      See Also:
        `ShortIndexable.viewList(List)`

    - #### toShortArray

          public static short[] toShortArray(@NotNull
                                             Countable<? extends java.lang.Number> c)

      Convert a countable of `Number`s to a raw array of shorts.
      Parameters:
        `c` - countable of Numbers
      Returns:
        array of shorts

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Short> toList(@NotNull
                                                                        short... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array
      See Also:
        `ShortIndexable.viewArray(short...)`

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Short> toList(@NotNull
                                                                        short[] array,
                                                                        int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Short> toList(@NotNull
                                                                        short[] array,
                                                                        int start,
                                                                        int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array
      See Also:
        `ShortIndexable.viewArray(short[], int, int)`

    - #### toIntArray

          public static int[] toIntArray(@NotNull
                                         java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of ints.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of ints
      See Also:
        `IntIndexable.viewList(List)`

    - #### toIntArray

          public static int[] toIntArray(@NotNull
                                         Countable<? extends java.lang.Number> c)

      Convert a countable of `Number`s to a raw array of ints.
      Parameters:
        `c` - countable Numbers
      Returns:
        array of ints

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                          int... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      >         public void method(Collection<Integer> input) {
      >           // ...
      >         }

      >         // ...
      >         method(Types.asList(0, 7, -42, 3));

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array
      See Also:
        `IntIndexable.viewArray(int...)`

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                          int[] array,
                                                                          int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                          int[] array,
                                                                          int start,
                                                                          int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array
      See Also:
        `IntIndexable.viewArray(int[], int, int)`

    - #### toLongArray

          public static long[] toLongArray(@NotNull
                                           java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of long ints.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of long ints

    - #### toLongArray

          public static long[] toLongArray(@NotNull
                                           Countable<? extends java.lang.Number> c)

      Convert a countable of `Number`s to a raw array of long ints.
      Parameters:
        `c` - countable Numbers
      Returns:
        array of long ints

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Long> toList(@NotNull
                                                                       long... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      >         public void method(Collection(<Long> input) {
      >           // ...
      >         }

      >         // ...
      >         method(Types.toList(0L, 7L, -42L, 3L));

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array
      See Also:
        `LongIndexable.viewArray(long...)`

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Long> toList(@NotNull
                                                                       long[] array,
                                                                       int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Long> toList(@NotNull
                                                                       long[] array,
                                                                       int start,
                                                                       int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array
      See Also:
        `LongIndexable.viewArray(long[], int, int)`

    - #### toDoubleArray

          @NotNull
          public static double[] toDoubleArray(@NotNull
                                                        java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of doubles.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of doubles

    - #### toDoubleArray

          @NotNull
          public static double[] toDoubleArray(@NotNull
                                                        Countable<? extends java.lang.Number> c)

      Convert a countable of `Number`s to a raw array of doubles.
      Parameters:
        `c` - countable Numbers
      Returns:
        array of doubles

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Double> toList(@NotNull
                                                                         double... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      >         public void method(Collection<Double> input) {
      >           // ...
      >         }

      >         // ...
      >         method(Types.toList(0.0, 7.1, -42.0, Math.PI));

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array
      See Also:
        `DoubleIndexable.viewArray(double...)`

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Double> toList(@NotNull
                                                                         double[] array,
                                                                         int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Double> toList(@NotNull
                                                                         double[] array,
                                                                         int start,
                                                                         int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array
      See Also:
        `DoubleIndexable.viewArray(double[], int, int)`

    - #### toFloatArray

          @NotNull
          public static float[] toFloatArray(@NotNull
                                                      java.util.Collection<? extends java.lang.Number> c)

      Convert a collection of `Number`s to a raw array of floats.
      Parameters:
        `c` - collection of Numbers
      Returns:
        array of floats

    - #### toFloatArray

          @NotNull
          public static float[] toFloatArray(@NotNull
                                                      Countable<? extends java.lang.Number> c)

      Convert a countable of `Number`s to a raw array of floats.
      Parameters:
        `c` - countable Numbers
      Returns:
        array of floats

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Float> toList(@NotNull
                                                                        float... array)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      Parameters:
        `array` - the array to wrap into a list view
      Returns:
        unmodifiable list accessing the array
      See Also:
        `FloatIndexable.viewArray(float...)`

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Float> toList(@NotNull
                                                                        float[] array,
                                                                        int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array

    - #### toList

          @NotNull
          public static java.util.List<java.lang.Float> toList(@NotNull
                                                                        float[] array,
                                                                        int start,
                                                                        int length)

      A more effective implementation of `Arrays.asList()`, useful if only an unmodifiable list is needed.

      Changes of the array will be reflected in the list return from this method.

      See `asList(Object[])` for an easy to adapt example.

      Parameters:
        `array` - the array to wrap into a list view
        `start` - index of first used element of the array
        `length` - the number of elements to be used from the array
      Returns:
        unmodifiable list accessing the array
      See Also:
        `FloatIndexable.viewArray(float[], int, int)`

    - #### toEnumeration

          @NotNull
           @SafeVarargs
          public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                                          T... item)

      Convert some items into an enumeration.
      Type Parameters:
        `T` - enumeration type
      Parameters:
        `item` - items
      Returns:
        enumeration

    - #### toEnumeration

          @NotNull
          public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                            java.lang.Iterable<T> iterable)

      Convert an iterable into an enumeration.
      Type Parameters:
        `T` - iterator type
      Parameters:
        `iterable` - the iterable
      Returns:
        enumeration

    - #### toEnumeration

          @NotNull
          public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                            java.util.Iterator<T> iterator)

      Convert an iterator into an enumeration.
      Type Parameters:
        `T` - iterator type
      Parameters:
        `iterator` - the iterator
      Returns:
        enumeration

    - #### toIterator

          @NotNull
          public static <T> java.util.Iterator<T> toIterator(@NotNull
                                                                      java.util.Enumeration<T> enumeration)

      Convert an enumeration into an iterator.
      Type Parameters:
        `T` - enumeration type
      Parameters:
        `enumeration` - the enumeration
      Returns:
        iterator

    - #### toIterator

          @NotNull
           @SafeVarargs
          public static <T> java.util.Iterator<T> toIterator(@NotNull
                                                                                    T... item)

      Convert some items into an iterator.
      Type Parameters:
        `T` - item type
      Parameters:
        `item` - items
      Returns:
        iterator

    - #### toIterable

          @NotNull
          public static <T> java.lang.Iterable<T> toIterable(@NotNull
                                                                      java.util.Enumeration<T> enumeration)

      Get a one shot iterable from an enumeration. The preferred usage of this is to wrap the enumeration so it can be used in a for each loop.
      Type Parameters:
        `T` - item type
      Parameters:
        `enumeration` - enumeration to wrap
      Returns:
        iterable which may only be used once, eg in a for each loop

    - #### containsEquals

          public static <T> boolean containsEquals(@NotNull
                                                   java.lang.Iterable<T> collection,
                                                   @NotNull
                                                   T element)

      Test whether a collection contains an element which is equal to another element. The standard Collection `contains()` method is sometimes erroneously checking for reference equality, while this method uses the `equals()` method. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for equality checking of the element.
      Type Parameters:
        `T` - generic parameter
      Parameters:
        `collection` - collection
        `element` - element which is looked up
      Returns:
        `true` if an element which is equal to the given one is contained in the collection
        `false` otherwise

    - #### findFirst

          @Nullable
          public static <T> T findFirst(@NotNull
                                                  java.lang.Iterable<T> iterable,
                                                  @NotNull
                                                  java.util.function.Predicate<? super T> check)

      Find the first element which fulfills the given check.
      Type Parameters:
        `T` - generic parameter
      Parameters:
        `iterable` - iterable with possibly matching elements
        `check` - check to perform
      Returns:
        first matching element or `null` if no matching element was found

    - #### findNext

          @Nullable
          public static <T> T findNext(@NotNull
                                                 java.util.Iterator<T> iterator,
                                                 @NotNull
                                                 java.util.function.Predicate<? super T> check)

      Find the nect element which fulfils the given check.
      Type Parameters:
        `T` - generic parameter
      Parameters:
        `iterator` - iterator which is advanced until the given element is found
        `check` - check to perform
      Returns:
        first matching element or `null` if no matching element was found

    - #### findNext

          @Nullable
          public static <T> T findNext(@NotNull
                                                 java.util.Enumeration<T> enumeration,
                                                 @NotNull
                                                 java.util.function.Predicate<? super T> check)

      Find the nect element which fulfils the given check.
      Type Parameters:
        `T` - generic parameter
      Parameters:
        `enumeration` - enumeration which is advanced until the given element is found
        `check` - check to perform
      Returns:
        first matching element or `null` if no matching element was found

    - #### findFirstEqual

          public static <T> int findFirstEqual(@NotNull
                                               java.lang.Iterable<T> collection,
                                               @NotNull
                                               T element)

      Find the first element in an collection which is equal to another element. The standard Collection `indexOf()` method is sometimes erroneously checking for reference equality, while this method uses the `equals()` method. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for equality checking of the element.
      Type Parameters:
        `T` - generic parameter
      Parameters:
        `collection` - collection
        `element` - element which is looked up
      Returns:
        `true` if an element which is equal to the given one is contained in the collection
        `false` otherwise

    - #### findFirstMatch

          public static <T,E> int findFirstMatch(@NotNull
                                                 java.lang.Iterable<T> collection,
                                                 @NotNull
                                                 E element,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T,? super E> matcher)

      Find the first element in a collection which is matching another element. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for match checking of the element.
      Type Parameters:
        `T` - generic parameter for iterator
        `E` - generic parameter for looked up element
      Parameters:
        `collection` - collection
        `element` - element which is looked up
        `matcher` - matcher which matches the elements in the iteration to the given element
      Returns:
        `true` if an element which is equal to the given one is contained in the collection
        `false` otherwise

    - #### addAll

          @NotNull
           @SafeVarargs
          public static <C extends java.util.Collection<? super T>,T> C addAll(@NotNull
                                                                                                      C collection,
                                                                                                      T... elements)

      Add all elements to a collection.
      Type Parameters:
        `C` - collection type
        `T` - element type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `elements` - elements to add
      Returns:
        the collection, allowing to create it on the fly when calling this method
      See Also:
        `Collections.addAll(Collection, Object[])`

    - #### addAll

          @NotNull
          public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                                C collection,
                                                                                @NotNull
                                                                                java.lang.Iterable<? extends T> iterable)

      Add all elements of an iterable to a collection.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `iterable` - iterable to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### addIterable

          @Deprecated
           @NotNull
          public static <C extends java.util.Collection<T>,T> C addIterable(@NotNull
                                                                                                  C collection,
                                                                                                  @NotNull
                                                                                                  java.lang.Iterable<? extends T> iterable)

      Deprecated. Use `addAll(Collection, Iterable)` instead
      Add an iterable to a collection.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `iterable` - iterable to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### addIterator

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<T>,T> C addIterator(@NotNull
                                                                                                  C collection,
                                                                                                  @NotNull
                                                                                                  java.util.Iterator<? extends T> iterator)

      Deprecated. Use `addAll(Collection, Iterator)` instead
      Add an iterator to a collection. This will propagate over the complete iteration, so it is after it's end after calling this method.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `iterator` - iterator to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### addAll

          @NotNull
          public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                                C collection,
                                                                                @NotNull
                                                                                java.util.Iterator<? extends T> iterator)

      Add all elements of an iterator to a collection. This will propagate over the complete iteration, so it is after it's end after calling this method.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `iterator` - iterator to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### addEnumeration

          @NotNull
           @Deprecated
          public static <C extends java.util.Collection<T>,T> C addEnumeration(@NotNull
                                                                                                     C collection,
                                                                                                     @NotNull
                                                                                                     java.util.Enumeration<? extends T> enumeration)

      Deprecated. Use `addAll(Collection, Enumeration)` instead
      Add an enumeration to a collection. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `enumeration` - enumeration to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### addAll

          @NotNull
          public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                                C collection,
                                                                                @NotNull
                                                                                java.util.Enumeration<? extends T> enumeration)

      Add all elements of an enumeration to a collection. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.
      Type Parameters:
        `C` - collection type
        `T` - collection/iterator type
      Parameters:
        `collection` - collection to add to, has to be modifiable
        `enumeration` - enumeration to add
      Returns:
        the collection, allowing to create it on the fly when calling this method

    - #### makeList

          @NotNull
          public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                                      java.lang.Iterable<T> iterable)

      Create a list from an iterable. This copies all elements of the iterable to a linked list.
      Type Parameters:
        `T` - iterable/list type
      Parameters:
        `iterable` - iterable
      Returns:
        linked list containing the elements of the iterable

    - #### makeList

          @NotNull
          public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                                      java.util.Iterator<T> iterator)

      Create a list from an iterator. This copies all elements of the iterator to a linked list.
      Type Parameters:
        `T` - iterator/list type
      Parameters:
        `iterator` - iterator
      Returns:
        linked list containing the elements of the iterator

    - #### makeList

          @NotNull
          public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                                      java.util.Enumeration<T> enumeration)

      Create a list from an enumeration. This copies all elements of the enumeration to a linked list.
      Type Parameters:
        `T` - enumeration/list type
      Parameters:
        `enumeration` - enumeration
      Returns:
        linked list containing the elements of the enumeration

    - #### toPairs

          @NotNull
          public static <K,V> java.util.ArrayList<OrderedPair<K,V>> toPairs(@NotNull
                                                                                     java.util.Map<K,V> map)

      Get all entries of a map as a list of ordered pairs. The map keys become the first pair value, the map values the second pair value.
      Type Parameters:
        `K` - map key / first pair value type
        `V` - map value / second pair value type
      Parameters:
        `map` - map to convert
      Returns:
        array list with ordered pair values

    - #### toPairs

          @NotNull
          public static <K,V,C extends java.util.Collection<OrderedPair<K,V>>> C toPairs(@NotNull
                                                                                                  C target,
                                                                                                  @NotNull
                                                                                                  java.util.Map<K,V> map)

      Get all entries of a map as a collection of ordered pairs. The map keys become the first pair value, the map values the second pair value.
      Type Parameters:
        `K` - map key / first pair value type
        `V` - map value / second pair value type
        `C` - collection type
      Parameters:
        `target` - collection where the pairs are added
        `map` - map to convert
      Returns:
        the target collection

    - #### synchronizedCollection

          @NotNull
          public static <T> java.util.Collection<T> synchronizedCollection(@NotNull
                                                                                    java.util.Collection<T> collection)

      Get a synchronized collection from a basic collection which is optimized for being often iterated, but rarely changed.

      To make the synchronization work it is adamant that the basic collection is never accessed directly, only via the returned collection. Different from `Collections.synchronizedCollection(java.util.Collection)` special handling for iterations is not necessary.

      Type Parameters:
        `T` - element type
      Parameters:
        `collection` - basic collection
      Returns:
        synchronized collection
      See Also:
        `SynchronizedCollection`

    - #### synchronizedList

          public static <T> java.util.List<T> synchronizedList(@NotNull
                                                               java.util.List<T> list)

      Get a synchronized list from a basic collection which is optimized for being often iterated, but rarely changed.

      To make the synchronization work it is adamant that the basic list is never accessed directly, only via the returned list. Different from `Collections.synchronizedList(List)` special handling for iterations is not necessary.

      Type Parameters:
        `T` - element type
      Parameters:
        `list` - basic list
      Returns:
        synchronized list
      See Also:
        `SynchronizedList`

    - #### extract

          @NotNull
          public static <T> java.util.LinkedList<T> extract(@NotNull
                                                                     java.lang.Object[] array,
                                                                     @NotNull
                                                                     java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
      Parameters:
        `array` - array with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.lang.Object[] array,
                                                                                         @NotNull
                                                                                         java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
        `C` - target collection type
      Parameters:
        `target` - target collection
        `array` - array with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T> java.util.LinkedList<T> extract(@NotNull
                                                                     java.lang.Iterable<?> iterable,
                                                                     @NotNull
                                                                     java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design.

      Example:

      >      public Collection<String> getStrings(Collection<?> collection) {
      >        return Types.extract(collection, String.class);
      >      }

      Type Parameters:
        `T` - target type
      Parameters:
        `iterable` - iterable with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.lang.Iterable<?> iterable,
                                                                                         @NotNull
                                                                                         java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
        `C` - target collection type
      Parameters:
        `target` - target collection
        `iterable` - iterable with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T> java.util.LinkedList<T> extract(@NotNull
                                                                     java.util.Iterator<?> iterator,
                                                                     @NotNull
                                                                     java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
      Parameters:
        `iterator` - iterator with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.util.Iterator<?> iterator,
                                                                                         @NotNull
                                                                                         java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
        `C` - target collection type
      Parameters:
        `target` - target collection
        `iterator` - iterator with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T> java.util.LinkedList<T> extract(@NotNull
                                                                     java.util.Enumeration<?> enumeration,
                                                                     @NotNull
                                                                     java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
      Parameters:
        `enumeration` - enumeration with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### extract

          @NotNull
          public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                                         C target,
                                                                                         @NotNull
                                                                                         java.util.Enumeration<?> enumeration,
                                                                                         @NotNull
                                                                                         java.lang.Class<T> targetType)

      Extract all elements of a given type.

      Internally this is using reflection, namely the `Class.isInstance(Object)` method, which is not considered fast. If you need this method often, rethink your design. Compare `extract(Iterable, Class)` for an easily adaptable example.

      Type Parameters:
        `T` - target type
        `C` - target collection type
      Parameters:
        `target` - target collection
        `enumeration` - enumeration with arbitrary elements
        `targetType` - type of elements which shall be extracted
      Returns:
        a linked list containing only the elements of the target type (including extending types)

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Collection<T1> c1,
                                                 @NotNull
                                                 java.util.Collection<T2> c2)

      Are two collections equal?

      This uses the `equals()` method of objects of the first collection for equality checking. Both collections are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first collection
        `T2` - type of second collection
      Parameters:
        `c1` - first collection
        `c2` - second collection
      Returns:
        `true` if both collections are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Collection<T1> c1,
                                                 @NotNull
                                                 java.util.Collection<T2> c2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two collections equal?

      Both collections are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first collection
        `T2` - type of second collection
      Parameters:
        `c1` - first collection
        `c2` - second collection
        `matcher` - matcher for equality checking
      Returns:
        `true` if both collection are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 Countable<T1> c1,
                                                 @NotNull
                                                 Countable<T2> c2)

      Are two countables equal?

      This uses the `equals()` method of objects of the first countabel for equality checking. Both countables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first countable
        `T2` - type of second countable
      Parameters:
        `c1` - first countable
        `c2` - second countable
      Returns:
        `true` if both countables are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 Countable<T1> c1,
                                                 @NotNull
                                                 Countable<T2> c2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two countables equal?

      Both countables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first countable
        `T2` - type of second countable
      Parameters:
        `c1` - first countable
        `c2` - second countable
        `matcher` - matcher for equality checking
      Returns:
        `true` if both countable are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 T1[] arr1,
                                                 @NotNull
                                                 T2[] arr2)

      Are two arrays equal?

      This uses the `equals()` method of objects of the first array for equality checking. Both arrays are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first array
        `T2` - type of second array
      Parameters:
        `arr1` - first array
        `arr2` - second array
      Returns:
        `true` if both arrays are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 T1[] arr1,
                                                 @NotNull
                                                 T2[] arr2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two arrays equal?

      Both arrays are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first array
        `T2` - type of second array
      Parameters:
        `arr1` - first array
        `arr2` - second array
        `matcher` - matcher for equality checking
      Returns:
        `true` if both arrays are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.lang.Iterable<T1> it1,
                                                 @NotNull
                                                 java.lang.Iterable<T2> it2)

      Are two iterables equal?

      This uses the `equals()` method of objects of the first iterable for equality checking. Both iterables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first iterable
        `T2` - type of second iterable
      Parameters:
        `it1` - first iterable
        `it2` - second iterable
      Returns:
        `true` if both iterables are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.lang.Iterable<T1> it1,
                                                 @NotNull
                                                 java.lang.Iterable<T2> it2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two iterables equal?

      Both iterables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first iterable
        `T2` - type of second iterable
      Parameters:
        `it1` - first iterable
        `it2` - second iterable
        `matcher` - matcher for equality checking
      Returns:
        `true` if both iterables are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Iterator<T1> it1,
                                                 @NotNull
                                                 java.util.Iterator<T2> it2)

      Are two iterations equal?

      This uses the `equals()` method of objects of the first iterator for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first iterator
        `T2` - type of second iterator
      Parameters:
        `it1` - first iterator
        `it2` - second iterator
      Returns:
        `true` if both iterators are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Iterator<T1> it1,
                                                 @NotNull
                                                 java.util.Iterator<T2> it2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two iterations equal?

      Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first iterator
        `T2` - type of second iterator
      Parameters:
        `it1` - first iterator
        `it2` - second iterator
        `matcher` - matcher for equality checking
      Returns:
        `true` if both iterators are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Enumeration<T1> en1,
                                                 @NotNull
                                                 java.util.Enumeration<T2> en2)

      Are two enumerators equal?

      This uses the `equals()` method of objects of the first enumeration for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first enumeration
        `T2` - type of second enumeration
      Parameters:
        `en1` - first enumeration
        `en2` - second enumeration
      Returns:
        `true` if both enumerations are equal
        `false` if they are different

    - #### areEqual

          public static <T1,T2> boolean areEqual(@NotNull
                                                 java.util.Enumeration<T1> en1,
                                                 @NotNull
                                                 java.util.Enumeration<T2> en2,
                                                 @NotNull
                                                 java.util.function.BiPredicate<? super T1,? super T2> matcher)

      Are two enumerators equal?

      This uses the `equals()` method of objects of the first enumeration for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

      Type Parameters:
        `T1` - type of first enumeration
        `T2` - type of second enumeration
      Parameters:
        `en1` - first enumeration
        `en2` - second enumeration
        `matcher` - matcher for equality checking
      Returns:
        `true` if both enumerations are equal
        `false` if they are different

    - #### areEqualSets

          public static <T> boolean areEqualSets(@NotNull
                                                 java.util.Collection<T> set1,
                                                 @NotNull
                                                 java.util.Collection<T> set2)

      Are the given sets equal. This method takes care of the fact that sets don't always have a defined order. It also assumes that the set-internal idea of equality is correct, by use of the set's `Collection.containsAll(Collection)` method.
      Type Parameters:
        `T` - element type of the sets
      Parameters:
        `set1` - first set of objects
        `set2` - second set of objects
      Returns:
        `true` if both sets contain the same

    - #### get

          public static <T> T get(@NotNull
                                  java.lang.Iterable<T> iterable,
                                  int index)

      Get the nth element of an iterable.
      Type Parameters:
        `T` - type of iterable
      Parameters:
        `iterable` - iterable
        `index` - index of requested element
      Returns:
        element with requested index
      Throws:
        `java.lang.IndexOutOfBoundsException` - if index is invalid

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          T[] array,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `array` - array to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `-1` if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          T[] array,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `array` - array to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.lang.Iterable<T> iterable,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `iterable` - iterable to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `-1` if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.lang.Iterable<T> iterable,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `iterable` - iterable to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.util.Iterator<T> iterator,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterator
        `E` - type of element
      Parameters:
        `iterator` - iterator to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.util.Iterator<T> iterator,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of iterator
        `E` - type of element
      Parameters:
        `iterator` - iterator to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.util.Enumeration<T> enumeration,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of enumeration
        `E` - type of element
      Parameters:
        `enumeration` - enumeration to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.util.Enumeration<T> enumeration,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of enumeration
        `E` - type of element
      Parameters:
        `enumeration` - enumeration to iterate over
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### indexOf

          public static <T,E> int indexOf(@NotNull
                                          java.util.List<T> list,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the first index where a given element appears.
      Type Parameters:
        `T` - type of list
        `E` - type of element
      Parameters:
        `list` - list to search through
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### lastIndexOf

          public static <T,E> int lastIndexOf(@NotNull
                                              java.util.List<T> list,
                                              E element,
                                              @NotNull
                                              java.util.function.BiPredicate<? super T,? super E> matcher,
                                              int start)

      Get the last index where a given element appears.
      Type Parameters:
        `T` - type of list
        `E` - type of element
      Parameters:
        `list` - list to search through
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### lastIndexOf

          public static <T,E> int lastIndexOf(@NotNull
                                              java.util.List<T> list,
                                              E element,
                                              @NotNull
                                              java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the last index where a given element appears.
      Type Parameters:
        `T` - type of list
        `E` - type of element
      Parameters:
        `list` - list to search through
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `-1` if no element was found, otherwise the index of the element

    - #### lastMatch

          public static <T,E> T lastMatch(@NotNull
                                          java.util.List<T> list,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher,
                                          int start)

      Get the last matching element from a list.
      Type Parameters:
        `T` - type of list
        `E` - type of element
      Parameters:
        `list` - list to search through
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
        `start` - index where to start the search
      Returns:
        `null` if no element was found, otherwise the matching element

    - #### lastMatch

          @Nullable
          public static <T,E> T lastMatch(@NotNull
                                                    java.util.List<T> list,
                                                    E element,
                                                    @NotNull
                                                    java.util.function.BiPredicate<? super T,? super E> matcher)

      Get the last matching element where a given element appears.
      Type Parameters:
        `T` - type of list
        `E` - type of element
      Parameters:
        `list` - list to search through
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher to use for equality checking
      Returns:
        `null` if no element was found, otherwise the matching element

    - #### contains

          public static <T,E> boolean contains(@NotNull
                                               T[] array,
                                               E element,
                                               @NotNull
                                               java.util.function.BiPredicate<? super T,? super E> matcher)

      Is an element contained in an array?
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `array` - array which possibly contains an element
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher for equality checking
      Returns:
        `true` if the element is contained (i.e. the matcher finds a match)
        `false` otherwise

    - #### contains

          public static <T,E> boolean contains(@NotNull
                                               java.lang.Iterable<T> iterable,
                                               E element,
                                               @NotNull
                                               java.util.function.BiPredicate<? super T,? super E> matcher)

      Is an element contained in an iterable?
      Type Parameters:
        `T` - type of iterable
        `E` - type of element
      Parameters:
        `iterable` - iterable which possibly contains an element
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher for equality checking
      Returns:
        `true` if the element is contained (i.e. the matcher finds a match)
        `false` otherwise

    - #### contains

          public static <T,E> boolean contains(@NotNull
                                               java.util.Iterator<T> iterator,
                                               E element,
                                               @NotNull
                                               java.util.function.BiPredicate<? super T,? super E> matcher)

      Is an element contained in an iterator?
      Type Parameters:
        `T` - type of iterator
        `E` - type of element
      Parameters:
        `iterator` - iterator which possibly contains an element
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher for equality checking
      Returns:
        `true` if the element is contained (i.e. the matcher finds a match)
        `false` otherwise

    - #### contains

          public static <T,E> boolean contains(@NotNull
                                               java.util.Enumeration<T> enumeration,
                                               E element,
                                               @NotNull
                                               java.util.function.BiPredicate<? super T,? super E> matcher)

      Is an element contained in an enumeration?
      Type Parameters:
        `T` - type of iterator
        `E` - type of element
      Parameters:
        `enumeration` - enumeration which possibly contains an element
        `element` - element to look for, whether `null` is allowed depends on the matcher
        `matcher` - matcher for equality checking
      Returns:
        `true` if the element is contained (i.e. the matcher finds a match)
        `false` otherwise

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                                     T[] array)

      Get a copy of an array, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `array` - array
      Returns:
        array list with copied elements
      See Also:
        `copy(Collection, Copyable[])`

    - #### copy

          @NotNull
          public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                                  C target,
                                                                                                  @NotNull
                                                                                                  T[] array)

      Get a copy of an array, while copying the content.
      Type Parameters:
        `T` - content type
        `C` - target collection type
      Parameters:
        `target` - target collection where the copies are stored
        `array` - array
      Returns:
        collection copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                                      java.lang.Iterable<T> iterable)

      Get a copy of an iterable, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `iterable` - iterable
      Returns:
        linked list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                                     Indexable<T> indexable)

      Get a copy of a indexable, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `indexable` - indexable collection
      Returns:
        array list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                                     java.util.Collection<T> collection)

      Get a copy of a collection, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `collection` - collection
      Returns:
        array list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                                     Countable<T> countable)

      Get a copy of a countable, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `countable` - countable
      Returns:
        array list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                                  C target,
                                                                                                  @NotNull
                                                                                                  java.lang.Iterable<T> iterable)

      Get a copy of an iterable, while copying the content.
      Type Parameters:
        `T` - content type
        `C` - target collection type
      Parameters:
        `target` - target collection where the copies are stored
        `iterable` - iterable
      Returns:
        collection copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                                      java.util.Iterator<T> iterator)

      Get a copy of an iterator, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `iterator` - iterator
      Returns:
        linked list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                                  C target,
                                                                                                  @NotNull
                                                                                                  java.util.Iterator<T> iterator)

      Get a copy of an iterator while copying the content.
      Type Parameters:
        `T` - content type
        `C` - target collection type
      Parameters:
        `target` - target collection where the copies are stored
        `iterator` - iterator
      Returns:
        collection copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                                      java.util.Enumeration<T> enumeration)

      Get a copy of an enumeration, while copying the content.
      Type Parameters:
        `T` - content type
      Parameters:
        `enumeration` - enumeration
      Returns:
        linked list with copied elements

    - #### copy

          @NotNull
          public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                                  C target,
                                                                                                  @NotNull
                                                                                                  java.util.Enumeration<T> enumeration)

      Get a copy of an enumeration while copying the content.
      Type Parameters:
        `T` - content type
        `C` - target collection type
      Parameters:
        `target` - target collection where the copies are stored
        `enumeration` - enumeration
      Returns:
        collection copied elements

    - #### join

          @NotNull
          public static java.lang.String join(@NotNull
                                                       java.lang.String glue,
                                                       @NotNull
                                                       java.lang.String... strings)

      Join an array of strings into one.
      Parameters:
        `glue` - string to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(char glue,
                                                       @NotNull
                                                       java.lang.String... strings)

      Join an array of strings into one.
      Parameters:
        `glue` - character to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(@NotNull
                                                       java.lang.String glue,
                                                       @NotNull
                                                       java.lang.Iterable<java.lang.String> strings)

      Join a bunch of strings into one.
      Parameters:
        `glue` - string to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(char glue,
                                                       @NotNull
                                                       java.lang.Iterable<java.lang.String> strings)

      Join a bunch of strings into one.
      Parameters:
        `glue` - character to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(char glue,
                                                       @NotNull
                                                       java.util.Iterator<java.lang.String> strings)

      Join a bunch of strings into one.
      Parameters:
        `glue` - scharacter to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(@NotNull
                                                       java.lang.String glue,
                                                       @NotNull
                                                       java.util.Iterator<java.lang.String> strings)

      Join a bunch of strings into one.
      Parameters:
        `glue` - string to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### join

          @NotNull
          public static java.lang.String join(@NotNull
                                                       java.lang.String glue,
                                                       @NotNull
                                                       java.util.Enumeration<java.lang.String> strings)

      Join a bunch of strings into one.
      Parameters:
        `glue` - string to use as separator
        `strings` - strings to join
      Returns:
        joined string

    - #### view

          @NotNull
          public static <T,S> java.util.Iterator<T> view(@NotNull
                                                                  java.util.Iterator<S> sourceIterator,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,? extends T> mapper)

      View an iterator as if it belongs to another type. Instead of `map(java.util.Iterator, Function)` this will work transparently on the fly without creating an intermediate list.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `sourceIterator` - source iterator
        `mapper` - mapper function which converts the source to the target type
      Returns:
        mapped iterator

    - #### view

          @NotNull
          public static <T,S> java.lang.Iterable<T> view(@NotNull
                                                                  java.lang.Iterable<S> sourceIterable,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,? extends T> mapper)

      View an iterable Instead of `map(java.lang.Iterable, Function)` this will work transparently on the fly.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `sourceIterable` - source iterable
        `mapper` - mapper function which converts the source to the target type
      Returns:
        mapped iterable

    - #### doubleView

          @NotNull
          public static <S> java.util.PrimitiveIterator.OfDouble doubleView(@NotNull
                                                                                     java.util.Iterator<S> sourceIterator,
                                                                                     @NotNull
                                                                                     java.util.function.ToDoubleFunction<? super S> doubleMapper)

      View a generic iterator as if it is an iterator for primitive double values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `doubleMapper` - mapper which maps the elements of the source iterator to `double`
      Returns:
        primitive double iterator

    - #### doubleView

          @NotNull
          public static <S> PrimitiveDoubleIterable doubleView(@NotNull
                                                                        java.lang.Iterable<S> sourceIterable,
                                                                        @NotNull
                                                                        java.util.function.ToDoubleFunction<? super S> doubleMapper)

      View a generic iterable as if it is an iterable of primitive `double` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned double iterable with its looping functions: `PrimitiveDoubleIterable.forEachDouble(DoubleConsumer)` or `PrimitiveDoubleIterable.forEachDoubleFragile(FragileDoubleConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `doubleMapper` - mapper from the incoming elements to double
      Returns:
        primitive double iterable

    - #### floatView

          @NotNull
          public static <S> PrimitiveFloatIterator floatView(@NotNull
                                                                      java.util.Iterator<S> sourceIterator,
                                                                      @NotNull
                                                                      ToFloatFunction<? super S> floatMapper)

      View a generic iterator as if it is an iterator for primitive float values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `floatMapper` - mapper which maps the elements of the source iterator to `float`
      Returns:
        primitive float iterator

    - #### floatView

          @NotNull
          public static <S> PrimitiveFloatIterable floatView(@NotNull
                                                                      java.lang.Iterable<S> sourceIterable,
                                                                      @NotNull
                                                                      ToFloatFunction<? super S> floatMapper)

      View a generic iterable as if it is an iterable of primitive `float` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned float iterable with its looping functions: `PrimitiveFloatIterable.forEachFloat(FloatConsumer)` or `PrimitiveFloatIterable.forEachFloatFragile(FragileFloatConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `floatMapper` - mapper from the incoming elements to float
      Returns:
        primitive float iterable

    - #### longView

          @NotNull
          public static <S> java.util.PrimitiveIterator.OfLong longView(@NotNull
                                                                                 java.util.Iterator<S> sourceIterator,
                                                                                 @NotNull
                                                                                 java.util.function.ToLongFunction<? super S> longMapper)

      View a generic iterator as if it is an iterator for primitive long values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `longMapper` - mapper which maps the elements of the source iterator to `long`
      Returns:
        primitive long iterator

    - #### longView

          @NotNull
          public static <S> PrimitiveLongIterable longView(@NotNull
                                                                    java.lang.Iterable<S> sourceIterable,
                                                                    @NotNull
                                                                    java.util.function.ToLongFunction<? super S> longMapper)

      View a generic iterable as if it is an iterable of primitive `long` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned long iterable with its looping functions: `PrimitiveLongIterable.forEachLong(LongConsumer)` or `PrimitiveLongIterable.forEachLongFragile(FragileLongConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `longMapper` - mapper from the incoming elements to long
      Returns:
        primitive long iterable

    - #### intView

          @NotNull
          public static <S> java.util.PrimitiveIterator.OfInt intView(@NotNull
                                                                               java.util.Iterator<S> sourceIterator,
                                                                               @NotNull
                                                                               java.util.function.ToIntFunction<? super S> intMapper)

      View a generic iterator as if it is an iterator for primitive int values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `intMapper` - mapper which maps the elements of the source iterator to `int`
      Returns:
        primitive int iterator

    - #### intView

          @NotNull
          public static <S> PrimitiveIntIterable intView(@NotNull
                                                                  java.lang.Iterable<S> sourceIterable,
                                                                  @NotNull
                                                                  java.util.function.ToIntFunction<? super S> intMapper)

      View a generic iterable as if it is an iterable of primitive `int` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned int iterable with its looping functions: `PrimitiveIntIterable.forEachInt(IntConsumer)` or `PrimitiveIntIterable.forEachIntFragile(FragileIntConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `intMapper` - mapper from the incoming elements to int
      Returns:
        primitive int iterable

    - #### shortView

          @NotNull
          public static <S> PrimitiveShortIterator shortView(@NotNull
                                                                      java.util.Iterator<S> sourceIterator,
                                                                      @NotNull
                                                                      ToShortFunction<? super S> shortMapper)

      View a generic iterator as if it is an iterator for primitive short values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `shortMapper` - mapper which maps the elements of the source iterator to `short`
      Returns:
        primitive short iterator

    - #### shortView

          @NotNull
          public static <S> PrimitiveShortIterable shortView(@NotNull
                                                                      java.lang.Iterable<S> sourceIterable,
                                                                      @NotNull
                                                                      ToShortFunction<? super S> shortMapper)

      View a generic iterable as if it is an iterable of primitive `short` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned short iterable with its looping functions: `PrimitiveShortIterable.forEachShort(ShortConsumer)` or `PrimitiveShortIterable.forEachShortFragile(FragileShortConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `shortMapper` - mapper from the incoming elements to short
      Returns:
        primitive short iterable

    - #### charView

          @NotNull
          public static <S> PrimitiveCharIterator charView(@NotNull
                                                                    java.util.Iterator<S> sourceIterator,
                                                                    @NotNull
                                                                    ToCharFunction<? super S> charMapper)

      View a generic iterator as if it is an iterator for primitive char values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `charMapper` - mapper which maps the elements of the source iterator to `char`
      Returns:
        primitive char iterator

    - #### charView

          @NotNull
          public static <S> PrimitiveCharIterable charView(@NotNull
                                                                    java.lang.Iterable<S> sourceIterable,
                                                                    @NotNull
                                                                    ToCharFunction<? super S> charMapper)

      View a generic iterable as if it is an iterable of primitive `char` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned char iterable with its looping functions: `PrimitiveCharIterable.forEachChar(CharConsumer)` or `PrimitiveCharIterable.forEachCharFragile(FragileCharConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `charMapper` - mapper from the incoming elements to char
      Returns:
        primitive char iterable

    - #### byteView

          @NotNull
          public static <S> PrimitiveByteIterator byteView(@NotNull
                                                                    java.util.Iterator<S> sourceIterator,
                                                                    @NotNull
                                                                    ToByteFunction<? super S> byteMapper)

      View a generic iterator as if it is an iterator for primitive byte values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `byteMapper` - mapper which maps the elements of the source iterator to `byte`
      Returns:
        primitive byte iterator

    - #### byteView

          @NotNull
          public static <S> PrimitiveByteIterable byteView(@NotNull
                                                                    java.lang.Iterable<S> sourceIterable,
                                                                    @NotNull
                                                                    ToByteFunction<? super S> byteMapper)

      View a generic iterable as if it is an iterable of primitive `byte` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned byte iterable with its looping functions: `PrimitiveByteIterable.forEachByte(ByteConsumer)` or `PrimitiveByteIterable.forEachByteFragile(FragileByteConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `byteMapper` - mapper from the incoming elements to byte
      Returns:
        primitive byte iterable

    - #### booleanView

          @NotNull
          public static <S> PrimitiveBooleanIterator booleanView(@NotNull
                                                                          java.util.Iterator<S> sourceIterator,
                                                                          @NotNull
                                                                          java.util.function.Predicate<? super S> booleanMapper)

      View a generic iterator as if it is an iterator for primitive boolean values.
      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterator` - source iterator
        `booleanMapper` - mapper which maps the elements of the source iterator to `boolean`
      Returns:
        primitive boolean iterator

    - #### booleanView

          @NotNull
          public static <S> PrimitiveBooleanIterable booleanView(@NotNull
                                                                          java.lang.Iterable<S> sourceIterable,
                                                                          @NotNull
                                                                          java.util.function.Predicate<? super S> booleanMapper)

      View a generic iterable as if it is an iterable of primitive `boolean` values.

      Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned boolean iterable with its looping functions: `PrimitiveBooleanIterable.forEachBool(BooleanConsumer)` or `PrimitiveBooleanIterable.forEachBoolFragile(FragileBooleanConsumer)` (if code throws checked exceptions).

      Type Parameters:
        `S` - source element type
      Parameters:
        `sourceIterable` - source iterable
        `booleanMapper` - mapper from the incoming elements to boolean
      Returns:
        primitive boolean iterable

    - #### view

          @NotNull
          public static <T,S> Indexable<T> view(@NotNull
                                                         Indexable<S> sourceIndexable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> mapper)

      View an indexable. Instead of `map(java.lang.Iterable, Function)` this will work transparently on the fly.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `sourceIndexable` - source indesxable
        `mapper` - mapper function which converts the source to the target type
      Returns:
        mapped iterable
      See Also:
        `Indexable.view(Function)`

    - #### view

          @NotNull
          public static <T,S> java.util.ListIterator<T> view(@NotNull
                                                                      java.util.ListIterator<S> sourceIterator,
                                                                      @NotNull
                                                                      java.util.function.Function<? super S,T> mapper)

      View a list iterator as if it belongs to another type. Instead of `map(java.util.Iterator, Function)` this will work transparently on the fly without creating an intermediate list.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `sourceIterator` - source iterator
        `mapper` - mapper function which converts the source to the target type
      Returns:
        mapped iterator

    - #### view

          @NotNull
           @SafeVarargs
          public static <T,S> java.lang.Iterable<T> view(@NotNull
                                                                                java.util.function.Function<? super S,T> mapper,
                                                                                @NotNull
                                                                                S... array)

      View an array as if it belongs to another iterable type.

      Changes to the array during the use of the resulting iterable will lead to undefined behavior.

      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `mapper` - mapper function which converts the source to the target type
        `array` - array to be view differently
      Returns:
        iterable over array providing a different type
      See Also:
        `Indexable.viewArray(Object[])`

    - #### viewCollection

          @NotNull
          public static <T,S> java.util.Collection<T> viewCollection(@NotNull
                                                                              java.util.Collection<S> collection,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> mapper)

      View a collection as if it has of another element type. This will return an unmodifiable collection with a different element type. It is considered useful in cases when you are in need of a readable collection, but only have one with a slightly different type. Compared to `map(Collection, Function)` this does not copy the collection, instead it applies the mapper on each access. So in general it is most useful when elements are rarely read, eg for iterating over them.

      Possible restrictions on the source collection (eg a set may contain elements only once, or it may be ordered) are no longer guaranteed by the returned collection. Use `map(Collection, Iterable, Function)` where you can provide the required target collection in cases where these restrictions are required.

      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `collection` - original collection
        `mapper` - mapper which creates the element type of the result collection
      Returns:
        unmodifiable collection with adapted element typee

    - #### viewList

          @NotNull
          public static <T,S> java.util.List<T> viewList(@NotNull
                                                                  java.util.List<S> list,
                                                                  @NotNull
                                                                  java.util.function.Function<? super S,T> mapper)

      View a list as if it has another element type. This will return an unmodifiable list with a different element type. It is considered useful in cases when you are in need of a readable list, but only have one with a slightly different type. Compared to `map(Collection, Function)` this does not copy the list, instead it applies the mapper on each access. So in general it is most useful when elements are rarely read, eg for iterating over them.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `list` - original list
        `mapper` - mapper which creates the element type of the result collection
      Returns:
        unmodifiable collection with adapted element typee

    - #### unmodifiable

          public static <T> java.util.Iterator<T> unmodifiable(@NotNull
                                                               java.util.Iterator<T> iterator)

      Wrap an iterator to keep it from modifying the underlying collection.

      The `Iterator` interface exports a method allowing to delete elements. The wrapper returned from this method will throw an `UnsupportedOperationException` for this method.

      Type Parameters:
        `T` - element type of iterator
      Parameters:
        `iterator` - iterator to wrap
      Returns:
        iterator which cannot modify the underlying collection

    - #### unmodifiable

          public static <T> java.util.ListIterator<T> unmodifiable(@NotNull
                                                                   java.util.ListIterator<T> iterator)

      Wrap a list iterator to keep it from modifying the underlying collection.

      The `ListIterator` interface exports methods allowing to modify the underlying list. The wrapper returned from this method will throw an `UnsupportedOperationException` for these methods.

      Type Parameters:
        `T` - element type of iterator
      Parameters:
        `iterator` - iterator to wrap
      Returns:
        iterator which cannot modify the underlying collection

    - #### makeFactory

          public static <T> Factory<T> makeFactory(java.lang.Class<T> type)

      Create a factory from a type.

      The factory will only create new objects if there is an argumentless public default constructor for the given type. This method is thought for highly dynamic situations. In most cases it is recommended to create a factory as an anonymous class:

      >      // this is BAD style
      >      Factory<XY> factory1 = Types.makeFactory(XY.class);

      >      // this is GOOD style
      >      Factory<XY> factory2 = new Factory<XY>() {
      >        public XY create() { return new XY(); }
      >      };

      Type Parameters:
        `T` - type
      Parameters:
        `type` - type info
      Returns:
        factory using reflection to create new elements

    - #### makeArrayFactory

          public static <T> ArrayFactory<T> makeArrayFactory(java.lang.Class<T> type)

      Create an array factory from a type.

      This method is thought for highly dynamic situations. In most cases it is recommended to create a factory as an anonymous class:

      >      // this is BAD style
      >      ArrayFactory<XY> factory1 = Types.makeArrayFactory(XY.class);

      >      // this is GOOD style
      >      ArrayFactory<XY> factory2 = new ArrayFactory<XY>() {
      >        public XY[] create(int length) { return new XY[length]; }
      >      };

      Type Parameters:
        `T` - type
      Parameters:
        `type` - type info
      Returns:
        factory using reflection to create new elements

    - #### asTypeConverter

          @NotNull
          public static <T,S> FragileTypeConverter<T,S> asTypeConverter(@NotNull
                                                                                 FragileFunction1<T,? extends java.lang.Exception,S> function)

      Use a fragile function with 1 argument as a type converter.
      Type Parameters:
        `T` - target type
        `S` - source type
      Parameters:
        `function` - function to use
      Returns:
        fragile type converter

    - #### emptyIterator

          @NotNull
          public static <T> java.util.Iterator<T> emptyIterator()

      Return an empty iterator which does not iterate. This is a low-cost method always returning the same object.
      Type Parameters:
        `T` - iteration type (ignored as no iteration is done)
      Returns:
        non-iterating iterator

    - #### emptyListIterator

          @NotNull
          public static <T> java.util.ListIterator<T> emptyListIterator()

      Return an empty list iterator which does not iterate. This is a low-cost method always returning the same object.
      Type Parameters:
        `T` - iteration element type (ignored as no iteration is done)
      Returns:
        non-iterating list iterator

    - #### emptyEnumeration

          @NotNull
          public static <T> java.util.Enumeration<T> emptyEnumeration()

      Return an empty enumeration which does not iterate. This is a low-cost method returning always the same object.
      Type Parameters:
        `T` - enumeration type (ignored as no iteration is done)
      Returns:
        non-iterating enumeration

    - #### emptyIterable

          @NotNull
          public static <T> java.lang.Iterable<T> emptyIterable()

      Return an empty iterable which does not iterate. This is a low-cost method returning always the same object.
      Type Parameters:
        `T` - iterable type (ignored as no iteration is done)
      Returns:
        non-iterating iterable

    - #### getCopier

          @NotNull
          public static <T extends Copyable<T>> java.util.function.Function<T,T> getCopier(@NotNull
                                                                                                    java.lang.Class<T> elemClass)

      Get a copier function which creates an copy of its argument.
      Type Parameters:
        `T` - class type, has to implement `Copyable`
      Parameters:
        `elemClass` - element class
      Returns:
        copier function

    - #### clone

          @NotNull
          public static <T> java.util.ArrayList<T> clone(@NotNull
                                                                  java.util.Collection<T> sourceCollection,
                                                                  @NotNull
                                                                  java.util.function.Function<T,T> cloner)

      Clone a collection.
      Type Parameters:
        `T` - list type
      Parameters:
        `sourceCollection` - source collection
        `cloner` - cloner which clones one list element
      Returns:
        array list with cloned elements

    - #### clone

          @NotNull
          public static <T> java.util.ArrayList<T> clone(@NotNull
                                                                  Countable<T> sourceCountable,
                                                                  @NotNull
                                                                  java.util.function.Function<T,T> cloner)

      Clone a countable.
      Type Parameters:
        `T` - list type
      Parameters:
        `sourceCountable` - source countable
        `cloner` - cloner which clones one list element
      Returns:
        array list with cloned elements

    - #### concat

          @SafeVarargs
           @NotNull
          public static <T> java.lang.Iterable<T> concat(@NotNull
                                                                                java.lang.Iterable<? extends T>... iterables)

      Concatenate some iterables to a combined iterable.
      Type Parameters:
        `T` - iteration element type
      Parameters:
        `iterables` - iterables to concatenate
      Returns:
        combined iterable which iterates over all the basic iterables one after the other

    - #### concatIterables

          @NotNull
          public static <T> java.lang.Iterable<T> concatIterables(@NotNull
                                                                           java.lang.Iterable<? extends java.lang.Iterable<? extends T>> iterables)

      Concatenate some iterables to a combined iterable.
      Type Parameters:
        `T` - iteration element type
      Parameters:
        `iterables` - iterables to concatenate
      Returns:
        combined iterable which iterates over all the basic iterables one after the other

    - #### concat

          @SafeVarargs
           @NotNull
          public static <T> java.util.Iterator<T> concat(@NotNull
                                                                                java.util.Iterator<? extends T>... iterators)

      Concatenate some iterators.
      Type Parameters:
        `T` - iteration element type
      Parameters:
        `iterators` - iterators to concatenate
      Returns:
        combined iterator which iterates over all the basic iterators one after the other

    - #### concatIterators

          @NotNull
          public static <T> java.util.Iterator<T> concatIterators(@NotNull
                                                                           java.lang.Iterable<? extends java.util.Iterator<? extends T>> iterators)

      Concatenate some iterators.
      Type Parameters:
        `T` - iteration element type
      Parameters:
        `iterators` - iterators to concatenate
      Returns:
        combined iterator which iterates over all the basic iterators one after the other

    - #### notNull

          @NotNull
          public static <T,D extends T> T notNull(@Nullable
                                                           T item,
                                                           @NotNull
                                                           D defaultValue)

      Make sure that something is not `null`. Use a default value if necessary.
      Type Parameters:
        `T` - item type
        `D` - default value type
      Parameters:
        `item` - item which may be `null`
        `defaultValue` - default value substituted if item is `null`
      Returns:
        `item` if it is not `null`, `defaultValue` otherwise

    - #### notNull

          @NotNull
          public static java.lang.String notNull(@Nullable
                                                          java.lang.String str)

      Make sure a string is not `null`. Use the empty string if necessary.
      Parameters:
        `str` - string which might be `null`
      Returns:
        the string if it is not `null`, the empty string otherwise

    - #### notNullOr

          @NotNull
          public static <T> T notNullOr(@Nullable
                                                 T item,
                                                 @NotNull
                                                 java.util.function.Supplier<? extends T> provider)

      Make sure that something is not `null`, but postpone the fallback creation. This is similar to `notNull(Object, Object)`, but is creating the second `defaultObject` parameter only when required. This is preferable if creating the object is an expensive process.
      Type Parameters:
        `T` - type of nullable value
      Parameters:
        `item` - item which is tested for being `null`
        `provider` - supplier asked to provide a fallback when `item` is `null`, required to return non-null object!
      Returns:
        non-null value, either `item` if it is not `null`, or a fallback created by `provider`
      Throws:
        `java.lang.IllegalArgumentException` - if provider creates `null`
      See Also:
        `notNullOrN(Object, Supplier)`

    - #### notNullOrN

          @Nullable
          public static <T> T notNullOrN(@Nullable
                                                   T item,
                                                   @NotNull
                                                   java.util.function.Supplier<? extends T> provider)

      Try to determine a fallback when a value is `null`.

      This is useful in cases where the fallback creation is expensive. In difference to `notNullOr(Object, Supplier)` this accepts the fallback provider to return `null`. Thus, it is necessary to check the result of this method for being `null`.

      Type Parameters:
        `T` - type of nullable value
      Parameters:
        `item` - item which is tested for being `null`
        `provider` - supplier asked to provide a fallback when `item` is `null`, allowed to reutn
      Returns:
        either `item` if it is not `null`, or a fallback created by `provider`

    - #### notEmpty

          @NotNull
          public static java.lang.String notEmpty(@Nullable
                                                           java.lang.String str,
                                                           @NotNull
                                                           java.lang.String fallback)

      Make sure a string is neither `null` nor empty.
      Parameters:
        `str` - string which might be `null` or empty
        `fallback` - fallback return when string is `null` or empty, should be not empty although this is not checked here
      Returns:
        `fallback` when `str` is `null` or empty, or `str` otherwise

    - #### isEmptyOrNull

          public static boolean isEmptyOrNull(@Nullable
                                              java.lang.String str)

      Check whether a string is empty or `null`.
      Parameters:
        `str` - the string to check
      Returns:
        `true`: if the string is empty or null
        `false`: otherwise

    - #### isWhiteOrNull

          public static boolean isWhiteOrNull(@Nullable
                                              java.lang.String str)

      Check whether a string is empty, contains only whitespace, or is `null`.
      Parameters:
        `str` - the string to check
      Returns:
        `true`: if the string contains only whitespace, is empty, or null
        `false`: otherwise

    - #### requireNonNull

          @NotNull
          public static <T> T requireNonNull(@Nullable
                                                      T item,
                                                      @NotNull
                                                      Procedure0 thrower)

      Require an item to be not null.
      Type Parameters:
        `T` - item type
      Parameters:
        `item` - item to check
        `thrower` - procedure called when item is `null`, expected to throw an appropriate unchecked exception
      Returns:
        non-null item
      Throws:
        `java.lang.NullPointerException` - if thrower does not throw anything
        `java.lang.RuntimeException` - anything thrower will throw

    - #### truePredicate

          @NotNull
          public static <T> java.util.function.Predicate<T> truePredicate()

      Return a predicate which returns always `true`. The returned predicate optimizes predicate chaining.
      Type Parameters:
        `T` - type of predicate parameter
      Returns:
        always true predicate

    - #### falsePredicate

          @NotNull
          public static <T> java.util.function.Predicate<T> falsePredicate()

      Return a predicate which returns always `false`. The returned predicate optimizes predicate chaining.
      Type Parameters:
        `T` - type of predicate parameter
      Returns:
        always true predicate

    - #### trueBiPredicate

          @NotNull
          public static <T1,T2> java.util.function.BiPredicate<T1,T2> trueBiPredicate()

      Return a bi-predicate which returns always `true`. The returned predicate optimizes predicate chaining.
      Type Parameters:
        `T1` - type of first parameter
        `T2` - type of second parameter
      Returns:
        always true bi-predicate

    - #### falseBiPredicate

          @NotNull
          public static <T1,T2> java.util.function.BiPredicate<T1,T2> falseBiPredicate()

      Return a bi-predicate which returns always `false`. The returned predicate optimizes predicate chaining.
      Type Parameters:
        `T1` - type of first parameter
        `T2` - type of second parameter
      Returns:
        always false bi-predicate

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Integer> indexable(@NotNull
                                                                        int... array)

      Return an indexable from a primitive integer array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `IntIndexable`

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Short> indexable(@NotNull
                                                                      short... array)

      Return an indexable from a primitive short integer array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `ShortIndexable`

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Long> indexable(@NotNull
                                                                     long... array)

      Return an indexable from a primitive long integer array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `LongIndexable`

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Byte> indexable(@NotNull
                                                                     byte... array)

      Return an indexable from a primitive byte integer array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `ByteIndexable`

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Double> indexable(@NotNull
                                                                       double... array)

      Return an indexable from a primitive double array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `DoubleIndexable`

    - #### indexable

          @NotNull
          public static Indexable<java.lang.Float> indexable(@NotNull
                                                                      float... array)

      Return an indexable from a primitive float array.
      Parameters:
        `array` - array on which the indexable is based
      Returns:
        indexable from array
      See Also:
        `FloatIndexable`

    - #### maxDouble

          public static double maxDouble(@NotNull
                                         double... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxDouble

          public static <T> double maxDouble(@NotNull
                                             java.lang.Iterable<T> iterable,
                                             @NotNull
                                             java.util.function.ToDoubleFunction<? super T> toDouble)

      Get the maximal double value from a double view of an iterable.
      Type Parameters:
        `T` - iterable element type
      Parameters:
        `iterable` - iterable (must not be empty!)
        `toDouble` - converter from the element type of the iterable to double
      Returns:
        maximal double value
      Throws:
        `java.lang.IllegalArgumentException` - if iterable is empty

    - #### maxDouble

          public static double maxDouble(@NotNull
                                         java.lang.Iterable<? extends java.lang.Number> iterable)

      Get the maximal double value for an iterable of numbers.
      Parameters:
        `iterable` - iterable (must not be empty!)
      Returns:
        maximal double value
      Throws:
        `java.lang.IllegalArgumentException` - if iterable is empty

    - #### minDouble

          public static double minDouble(@NotNull
                                         double... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minDouble

          public static <T> double minDouble(@NotNull
                                             java.lang.Iterable<T> iterable,
                                             @NotNull
                                             java.util.function.ToDoubleFunction<? super T> toDouble)

      Get the minimal double value from a double view of an iterable.
      Type Parameters:
        `T` - iterable element type
      Parameters:
        `iterable` - iterable (must not be empty!)
        `toDouble` - converter from the element type of the iterable to double
      Returns:
        minimal double value
      Throws:
        `java.lang.IllegalArgumentException` - if iterable is empty

    - #### minDouble

          public static double minDouble(@NotNull
                                         java.lang.Iterable<? extends java.lang.Number> iterable)

      Get the minimal double value for an iterable of numbers.
      Parameters:
        `iterable` - iterable (must not be empty!)
      Returns:
        minimal double value
      Throws:
        `java.lang.IllegalArgumentException` - if iterable is empty

    - #### maxFloat

          public static float maxFloat(@NotNull
                                       float... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minFloat

          public static float minFloat(@NotNull
                                       float... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxLong

          public static long maxLong(@NotNull
                                     long... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minLong

          public static long minLong(@NotNull
                                     long... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxInt

          public static int maxInt(@NotNull
                                   int... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minInt

          public static int minInt(@NotNull
                                   int... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxShort

          public static short maxShort(@NotNull
                                       short... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minShort

          public static short minShort(@NotNull
                                       short... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxByte

          public static byte maxByte(@NotNull
                                     byte... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minByte

          public static byte minByte(@NotNull
                                     byte... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### maxChar

          public static char maxChar(@NotNull
                                     char... values)

      Get the maximal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        maximal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### minChar

          public static char minChar(@NotNull
                                     char... values)

      Get the minimal value.
      Parameters:
        `values` - values to check, at least 1
      Returns:
        minimal value
      Throws:
        `java.lang.IllegalArgumentException` - if there are no values

    - #### min

          @NotNull
           @SafeVarargs
          public static <T> T min(@NotNull
                                                         java.util.Comparator<? super T> comparator,
                                                         @NotNull
                                                         T... values)

      Get the minimal value from an array of values.
      Type Parameters:
        `T` - value type
      Parameters:
        `comparator` - comparator defining how values are ordered
        `values` - values, at least 1
      Returns:
        minimal value

    - #### min

          @NotNull
           @SafeVarargs
          public static <T extends java.lang.Comparable<? super T>> T min(@NotNull
                                                                                                 T... values)

      Get the minimal value from an array of comparable values.
      Type Parameters:
        `T` - value type
      Parameters:
        `values` - values, at least 1
      Returns:
        minimal value

    - #### min

          @NotNull
          public static <T> T min(@NotNull
                                           java.util.Comparator<? super T> comparator,
                                           @NotNull
                                           java.lang.Iterable<T> values)

      Get the minimal value from some values.
      Type Parameters:
        `T` - value type
      Parameters:
        `comparator` - comparator defining how values are ordered
        `values` - values, at least 1
      Returns:
        minimal value

    - #### min

          @NotNull
          public static <T extends java.lang.Comparable<? super T>> T min(@NotNull
                                                                                   java.lang.Iterable<T> values)

      Get the minimal value from some comparable values.
      Type Parameters:
        `T` - value type
      Parameters:
        `values` - values, at least 1
      Returns:
        minimal value

    - #### max

          @NotNull
           @SafeVarargs
          public static <T> T max(@NotNull
                                                         java.util.Comparator<? super T> comparator,
                                                         T... values)

      Get the maximal value from an array of values.
      Type Parameters:
        `T` - value type
      Parameters:
        `comparator` - comparator defining how values are ordered
        `values` - values, at least 1
      Returns:
        maximal value

    - #### max

          @NotNull
           @SafeVarargs
          public static <T extends java.lang.Comparable<? super T>> T max(T... values)

      Get the maximal value from an array of comparable values.
      Type Parameters:
        `T` - value type
      Parameters:
        `values` - values, at least 1
      Returns:
        maximal value

    - #### max

          @NotNull
          public static <T> T max(@NotNull
                                           java.util.Comparator<? super T> comparator,
                                           @NotNull
                                           java.lang.Iterable<T> values)

      Get the maximal value from some values.
      Type Parameters:
        `T` - value type
      Parameters:
        `comparator` - comparator defining how values are ordered
        `values` - values, at least 1
      Returns:
        maximal value

    - #### max

          @NotNull
          public static <T extends java.lang.Comparable<? super T>> T max(@NotNull
                                                                                   java.lang.Iterable<T> values)

      Get the maximal value from some comparable values.
      Type Parameters:
        `T` - value type
      Parameters:
        `values` - values, at least 1
      Returns:
        maximal value

    - #### fillTight

          public static <T,S> void fillTight(@NotNull
                                             java.util.ArrayList<T> list,
                                             @NotNull
                                             java.lang.Iterable<S> elements,
                                             @NotNull
                                             java.util.function.Function<? super S,? extends T> mapper)

      Fill an array list with a number of elements. After the call the list will have lost possible previous elements, and be filled with the mapped incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list
        `S` - element type of incoming elements
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in
        `mapper` - mapper from incoming elements to list elements

    - #### fillTight

          public static <T> void fillTight(@NotNull
                                           java.util.ArrayList<T> list,
                                           @NotNull
                                           java.lang.Iterable<? extends T> elements)

      Fill an array list with a number of alements. After the call the list will have lost possible previous elements, and be filled with the incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list, incoming iterable may extend this
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in

    - #### fillTight

          public static <T,S> void fillTight(@NotNull
                                             java.util.ArrayList<T> list,
                                             @NotNull
                                             java.util.Collection<S> elements,
                                             @NotNull
                                             java.util.function.Function<? super S,? extends T> mapper)

      Fill an array list with a number of elements. After the call the list will have lost possible previous elements, and be filled with the mapped incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list
        `S` - element type of incoming elements
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in
        `mapper` - mapper from incoming elements to list elements

    - #### fillTight

          public static <T,S> void fillTight(@NotNull
                                             java.util.ArrayList<T> list,
                                             @NotNull
                                             Countable<S> elements,
                                             @NotNull
                                             java.util.function.Function<? super S,? extends T> mapper)

      Fill an array list with a number of elements. After the call the list will have lost possible previous elements, and be filled with the mapped incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list
        `S` - element type of incoming elements
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in
        `mapper` - mapper from incoming elements to list elements

    - #### fillTight

          public static <T> void fillTight(@NotNull
                                           java.util.ArrayList<T> list,
                                           @NotNull
                                           java.util.Collection<? extends T> elements)

      Fill an array list with a number of alements. After the call the list will have lost possible previous elements, and be filled with the incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list, incoming iterable may extend this
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in

    - #### fillTight

          public static <T> void fillTight(@NotNull
                                           java.util.ArrayList<T> list,
                                           @NotNull
                                           Countable<? extends T> elements)

      Fill an array list with a number of alements. After the call the list will have lost possible previous elements, and be filled with the incoming elements. The list will also be `ArrayList.trimToSize()`.
      Type Parameters:
        `T` - element type of result list, incoming iterable may extend this
      Parameters:
        `list` - list to be filled
        `elements` - elements to fill in

    - #### fillArray

          public static <T> void fillArray(@NotNull
                                           T[] array,
                                           int start,
                                           int length,
                                           @NotNull
                                           java.util.function.Supplier<? extends T> supplier)

      Fill part of an array with elements provided by a supplier.
      Type Parameters:
        `T` - array type
      Parameters:
        `array` - array to fill
        `start` - first index to be filled
        `length` - number of elements filled from `start`
        `supplier` - supplier called for each element to be filled

    - #### fillArray

          public static <T> void fillArray(@NotNull
                                           T[] array,
                                           @NotNull
                                           java.util.function.Supplier<? extends T> supplier)

      Fill an array with elements provided by a supplier.
      Type Parameters:
        `T` - array type
      Parameters:
        `array` - array to fill
        `supplier` - supplier called for each element to be filled

    - #### lexicalCompare

          public static <T> int lexicalCompare(@NotNull
                                               java.lang.Iterable<? extends T> it1,
                                               @NotNull
                                               java.lang.Iterable<? extends T> it2,
                                               @NotNull
                                               java.util.Comparator<T> comparator)

      Compare two iterables in lexical order. This means that the first difference between the two iterables determines the order. If one is a prefix of the other it is considered first in order, and only if both iterables contain the same number of elements which are equal (as given by order) `0` is returned.
      Type Parameters:
        `T` - common element type
      Parameters:
        `it1` - first iterable
        `it2` - second iterable
        `comparator` - comparator for the elements of the iterables
      Returns:
        less than `0` if `it1 < it2`, greater than `0` if `it1 > it2`, and `0` if both sequences are considered equal

    - #### lexicalCompare

          public static <T extends java.lang.Comparable<T>> int lexicalCompare(@NotNull
                                                                               java.lang.Iterable<? extends T> it1,
                                                                               @NotNull
                                                                               java.lang.Iterable<? extends T> it2)

      Compare two iterables in lexical natural order. This means that the first difference between the two iterables determines the order. If one is a prefix of the other it is considered first in order, and only if both iterables contain the same number of elements which are equal (as given by order) `0` is returned.
      Type Parameters:
        `T` - comparable element type
      Parameters:
        `it1` - first iterable of comparable elements
        `it2` - second iterable of comparable elements
      Returns:
        less than `0` if `it1 < it2`, greater than `0` if `it1 > it2`, and `0` if both sequences are considered equal

    - #### lexicalCompare

          public static <T> int lexicalCompare(@NotNull
                                               java.util.Iterator<? extends T> it1,
                                               @NotNull
                                               java.util.Iterator<? extends T> it2,
                                               @NotNull
                                               java.util.Comparator<T> comparator)

      Compare two iterators in lexical order. This means that the first difference between the two iterables determines the order. If one is a prefix of the other it is considered first in order, and only if both iterables contain the same number of elements which are equal (as given by order) `0` is returned.
      Type Parameters:
        `T` - common element type
      Parameters:
        `it1` - first iterator, placed after the first difference on return
        `it2` - second iterator, placed after the first difference on return
        `comparator` - comparator for the elements of the iterators
      Returns:
        less than `0` if `it1 < it2`, greater than `0` if `it1 > it2`, and `0` if both sequences are considered equal

    - #### lexicalCompare

          public static <T extends java.lang.Comparable<T>> int lexicalCompare(@NotNull
                                                                               java.util.Iterator<? extends T> it1,
                                                                               @NotNull
                                                                               java.util.Iterator<? extends T> it2)

      Compare two iterators in lexical natural order. This means that the first difference between the two iterators determines the order. If one is a prefix of the other it is considered first in order, and only if both iterables contain the same number of elements which are equal (as given by order) `0` is returned.
      Type Parameters:
        `T` - comparable element type
      Parameters:
        `it1` - first iterator, placed after the first difference on return
        `it2` - second iterator, placed after the first difference on return
      Returns:
        less than `0` if `it1 < it2`, greater than `0` if `it1 > it2`, and `0` if both sequences are considered equal

    - #### hash

          public static int hash(@NotNull
                                 java.lang.Iterable<?> iterable)

      Calculate a hash code for a generic iterable. This methods sums up the hash codes of all elements of the iterable. This implementation follows `Arrays.hashCode(Object[])`, so for an array with with the same elements as the given iterable the results are the same.
      Parameters:
        `iterable` - iterable for which the hash code is required
      Returns:
        hash code

    - #### findAnyKey

          @Nullable
          public static <K,V> K findAnyKey(@NotNull
                                                     java.util.Map<K,V> map,
                                                     @NotNull
                                                     java.util.function.Predicate<? super V> valueChecker)

      Find the first key in a map which the given value checker accepts.
      Type Parameters:
        `K` - map key type
        `V` - map value type
      Parameters:
        `map` - map to search
        `valueChecker` - value checker
      Returns:
        first matching key, or `null` if no value matches

    - #### findAnyEntry

          @Nullable
          public static <K,V> java.util.Map.Entry<K,V> findAnyEntry(@NotNull
                                                                              java.util.Map<K,V> map,
                                                                              @NotNull
                                                                              Predicate2<? super K,? super V> entryChecker)

      Find the first entry in a map which the given entry checker accepts.
      Type Parameters:
        `K` - map key type
        `V` - map value type
      Parameters:
        `map` - map to search
        `entryChecker` - entry checker
      Returns:
        first matching key, or `null` if no value matches

    - #### findAllEntries

          @NotNull
          public static <K,V> java.util.Set<java.util.Map.Entry<K,V>> findAllEntries(@NotNull
                                                                                              java.util.Map<K,V> map,
                                                                                              @NotNull
                                                                                              Predicate2<? super K,? super V> entryChecker)

      Return all entries which which the given checker accepts.
      Type Parameters:
        `K` - map key type
        `V` - map value type
      Parameters:
        `map` - map to filter
        `entryChecker` - entry checker which marks the entries for the result
      Returns:
        set of matching entries

    - #### containsAny

          public static <T> boolean containsAny(@NotNull
                                                java.util.Collection<T> set,
                                                @NotNull
                                                java.lang.Iterable<? extends T> possibleElements)

      Check whether any of a bunch of elements is contained in a collection.
      Type Parameters:
        `T` - element type of the set
      Parameters:
        `set` - collection, often a `Set`
        `possibleElements` - possible elements which may be contained in the `set`
      Returns:
        `true` if at least one of the possible elements is contained in `set`
        `false` if none is contained, or `set` or `possibleElements` is empty

    - #### separate

          public static <T> void separate(@NotNull
                                          java.lang.Iterable<T> elements,
                                          @NotNull
                                          java.util.function.Consumer<? super T> trueCollect,
                                          @NotNull
                                          java.util.function.Consumer<? super T> falseCollect,
                                          @NotNull
                                          java.util.function.Predicate<? super T> condition)

      Go over an iterable and sepparate its elements depending a condition.
      Type Parameters:
        `T` - element type
      Parameters:
        `elements` - elements to be separated
        `trueCollect` - collector for the elements where `condition` returned `true`
        `falseCollect` - collector for the elements where `condition` returned `false`
        `condition` - condition applied to the elements

    - #### separate

          public static <T> void separate(@NotNull
                                          java.lang.Iterable<T> elements,
                                          @NotNull
                                          java.util.Collection<? super T> trueCollect,
                                          @NotNull
                                          java.util.Collection<? super T> falseCollect,
                                          @NotNull
                                          java.util.function.Predicate<? super T> condition)

      Go over an iterable and sepparate its elements depending a condition.
      Type Parameters:
        `T` - element type
      Parameters:
        `elements` - elements to be separated
        `trueCollect` - collector for the elements where `condition` returned `true`
        `falseCollect` - collector for the elements where `condition` returned `false`
        `condition` - condition applied to the elements

    - #### separate

          @NotNull
          public static <T,C extends java.util.Collection<? super T>> Pair<C> separate(@NotNull
                                                                                                java.lang.Iterable<T> elements,
                                                                                                @NotNull
                                                                                                java.util.function.Supplier<C> slotCreator,
                                                                                                @NotNull
                                                                                                java.util.function.Predicate<? super T> condition)

      Fo over an iterable and separate its elements depending on a condition. This method allows to define the slot type into which the elements are separated.
      Type Parameters:
        `T` - element type
        `C` - return type
      Parameters:
        `elements` - elements to be separated
        `slotCreator` - slot creator called twice to create the collection into which the results are separated
        `condition` - condition which decides whether an element goes to the results' first collection (`true`), or to its second collection (`false`
      Returns:
        pair of two C collections, `first` contains the positive results, `second` the negative

    - #### separate

          @NotNull
          public static <T> Pair<java.util.LinkedList<T>> separate(@NotNull
                                                                            java.lang.Iterable<T> elements,
                                                                            @NotNull
                                                                            java.util.function.Predicate<? super T> condition)

      Go over an iterable and separate its elements into two lists depending on a condition.
      Type Parameters:
        `T` - element type
      Parameters:
        `elements` - elements to be separated
        `condition` - condition which decides whether an element goes to the results' first list (`true`), or to its second list (`false`
      Returns:
        pair of two linked lists, `first` contains the positive results, `second` the negative

    - #### spaces

          @NotNull
          public static java.lang.String spaces(int count)

      This creates a string consisting only of spaces which is sometimes useful.
      Parameters:
        `count` - number of spaces, must not be negative
      Returns:
        string with as many spaces as required
      See Also:
        `multiple(String, int)`

    - #### multiple

          @NotNull
          public static java.lang.String multiple(char ch,
                                                           int count)

      Create a string from multiple repetitions of a character.
      Parameters:
        `ch` - the character
        `count` - the number of repetitions, not negative
      Returns:
        string created from concatenating `ch` `count` times
      See Also:
        `spaces(int)`, `multiple(String, int)`

    - #### multiple

          @NotNull
          public static java.lang.String multiple(@NotNull
                                                           java.lang.String str,
                                                           int count)

      Create a string from a base string repeated multiple times.
      Parameters:
        `str` - base string
        `count` - the number of repetitions, not negative
      Returns:
        string created from concatenating `str` `count` times
      See Also:
        `spaces(int)`

    - #### reversedList

          @NotNull
          public static <T> java.util.List<T> reversedList(@NotNull
                                                                    java.util.List<T> list)

      Create a list in reverse order for a given list. This is a List method on its own in newer Java versions, and should only be used for Java8 compatibility.
      Type Parameters:
        `T` - element type of both lists
      Parameters:
        `list` - list to be reverted
      Returns:
        reverted list