Package de.scravy.bedrock

Class Seq<E>

java.lang.Object

de.scravy.bedrock.Seq<E>

Type Parameters:

E - The type of the Elements contained in this Sequence.

All Implemented Interfaces:

Container<E>, ExtendedIterable<E>, HasLengthAtLeast, Serializable, Iterable<E>, IntFunction<E>, RandomAccess

@Immutable
public abstract class Seq<E>
extends Object
implements Serializable, RandomAccess, Container<E>, IntFunction<E>

An immutable sequence.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	Seq.WithIndexConsumer<E>	Deprecated.

Nested classes/interfaces inherited from interface de.scravy.bedrock.ExtendedIterable

ExtendedIterable.ForEachWithIndexConsumer<T>

Field Summary

Fields

Modifier and Type	Field	Description
static Comparator<Object>	NULL_ACCEPTING_COMPARATOR
static long	serialVersionUID

Constructor Summary

Constructors

Constructor	Description
Seq()

Method Summary

Modifier and Type	Method	Description
static boolean	all(Seq<Boolean> seq)
static boolean	and(Seq<Boolean> seq)
static boolean	any(Seq<Boolean> seq)
E	apply(int index)
String	asString(String delimiter)
Pair<Seq<E>,Seq<E>>	breakBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	breakByView(Predicate<? super E> predicate)
static <E> SeqBuilder<E>	builder()
static <E> SeqBuilder<E>	builder(int sizeHint)
static Seq<Integer>	codepointsOfString(String string)
static <T> Collector<T,SeqBuilder<T>,Seq<T>>	collector()
static <E, A extends E, B extends E> Seq<A>	commonPrefix(Seq<A> as, Seq<B> bs)
static <A, B> int	commonPrefixLength(Seq<A> as, Seq<B> bs)
static <E, A extends E, B extends E> Seq<A>	commonPrefixView(Seq<A> as, Seq<B> bs)
static <E> Seq<E>	concat(Seq<E>... seqs)
static <E> Seq<E>	concatView(Seq<E>... seqs)
boolean	contains(E e)
int	count(E e)
int	countBy(Predicate<? super E> predicate)
Seq<E>	distinct()	Returns a copy of this Seq with no duplicates.
static double	doubleProduct(Seq<Double> seq)
static double	doubleSum(Seq<Double> seq)
E	draw(Random random)
default Seq<E>	drop(int length)
default Seq<E>	dropRight(int length)
default Seq<E>	dropRightView(int length)
default Seq<E>	dropView(int length)
Seq<E>	dropWhile(Predicate<? super E> predicate)
Seq<E>	dropWhileView(Predicate<? super E> predicate)
static <E> Seq<E>	empty()
default boolean	endsWith(Seq<E> sequence)
boolean	equals(Object that)
boolean	exists(Predicate<? super E> predicate)
<F extends E> Seq<F>	filter(Class<F> clazz)
Seq<E>	filter(Predicate<? super E> predicate)
Seq<E>	filterNot(Predicate<? super E> predicate)
int	find(E e)
int	findBy(Predicate<? super E> predicate)
Optional<E>	findFirst(Predicate<? super E> predicate)
<F> Seq<F>	flatMap(Function<? super E,Seq<F>> function)
<F> Seq<F>	flatMapIterable(Function<? super E,? extends Iterable<F>> function)
<F> Seq<F>	flatMapOptional(Function<? super E,Optional<F>> function)
<A> A	foldl(BiFunction<? super A,? super E,? extends A> function, A startValue)
E	foldl1(BiFunction<? super E,? super E,? extends E> function)
<A> A	foldl1f(BiFunction<? super A,? super E,? extends A> function, Function<? super E,? extends A> startValueFunction)
<A> A	foldr(BiFunction<? super E,? super A,? extends A> function, A startValue)
E	foldr1(BiFunction<? super E,? super E,? extends E> function)
<A> A	foldr1f(BiFunction<? super E,? super A,? extends A> function, Function<? super E,? extends A> startValueFunction)
boolean	forAll(Predicate<? super E> predicate)
abstract E	get(int index)
Seq<Seq<E>>	group()
Seq<Seq<E>>	groupBy(BiPredicate<? super E,? super E> operator)
int	hashCode()
E	head()
Optional<E>	headOptional()
default Seq<E>	init()
Seq<Seq<E>>	inits()
Seq<Seq<E>>	initsView()
default Seq<E>	initView()
Seq<E>	intercalate(Seq<E> seq)
Seq<E>	intersect(Seq<E> seq)	Returns a distinct Seq that contains only the elements that occur in both sets.
Seq<E>	intersperse(E e)
static int	intProduct(Seq<Integer> seq)
static int	intSum(Seq<Integer> seq)
boolean	isEmpty()
Iterator<E>	iterator()
E	last()
Optional<E>	lastOptional()
int	length()
static long	longProduct(Seq<Long> seq)
static long	longSum(Seq<Long> seq)
<F> Seq<F>	map(Function<? super E,? extends F> function)
E	maximum()
static <E extends Comparable<? super E>> E	maximum(Seq<E> seq)
E	maximumBy(Comparator<? super E> comparator)
E	minimum()
static <E extends Comparable<? super E>> E	minimum(Seq<E> seq)
E	minimumBy(Comparator<? super E> comparator)
static <E> Seq<E>	of(E... es)
static <E> Seq<E>	ofArray(E[] array)
static <E> Seq<E>	ofCollection(Collection<? extends E> collection)
static <E> Seq<E>	ofGenerator(IntFunction<E> function, int length)
static <E> Seq<E>	ofGeneratorMemoizing(IntFunction<E> function, int length)
static <E> Seq<E>	ofIterable(Iterable<? extends E> iterable)
static <E> Seq<E>	ofIterator(Iterator<? extends E> iterator)
static <C, A extends C, B extends C> Seq<C>	ofPair(Pair<A,B> pair)
static Seq<Character>	ofString(String string)
static boolean	or(Seq<Boolean> seq)
Pair<Seq<E>,Seq<E>>	partitionBy(Predicate<? super E> predicate)
Seq<Seq<E>>	permutations()
default Iterable<Seq<E>>	permutationsIterable()
Iterator<Seq<E>>	permutationsIterator()
default Stream<Seq<E>>	permutationsStream()
static Seq<Integer>	rangeExclusive(int from, int to)
static Seq<Integer>	rangeInclusive(int from, int to)
Seq<E>	reversed()
Iterator<E>	reverseIterator()
Seq<E>	rotated(int amount)	Rotates the list by amount positions.
static <E> Seq<E>	seq(E... es)
default Seq<E>	shuffled()
Seq<E>	shuffled(Random random)
default int	size()	Exactly the same as length().
Seq<E>	sorted()
abstract Seq<E>	sortedBy(Comparator<? super E> comparator)
<F extends Comparable<? super F>> Seq<E>	sortedOn(Function<? super E,? extends F> function)
Pair<Seq<E>,Seq<E>>	spanBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	spanByView(Predicate<? super E> predicate)
default boolean	startsWith(Seq<E> sequence)
Seq<E>	subSequence(int beginOffset, int endOffset)
Seq<E>	subSequenceView(int beginOffset, int endOffset)
default Seq<E>	tail()
Seq<Seq<E>>	tails()
Seq<Seq<E>>	tailsView()
default Seq<E>	tailView()
default Seq<E>	take(int length)
default Seq<E>	takeRight(int length)
default Seq<E>	takeRightView(int length)
default Seq<E>	takeView(int length)
Seq<E>	takeWhile(Predicate<? super E> predicate)
Seq<E>	takeWhileView(Predicate<? super E> predicate)
abstract Object[]	toArray()
abstract E[]	toArray(Class<E> clazz)
<K extends Comparable<K>> ArrayMap<K,Seq<E>>	toArrayMap(Function<? super E,? extends K> groupingFunction)
List<E>	toList()	Create a java.util.List that contains the elements of this sequence.
<K> Mapping<K,Seq<E>>	toMap(Function<? super E,? extends K> groupingFunction)
String	toString()
Seq<E>	trimmedToSize()
Seq<E>	union(Seq<E> seq)	Returns a distinct Seq that contains the elements from both this Seq and the given Seq.
Seq<E>	without(Seq<E> seq)	Returns a Seq with the elements from the given Seq removed.
static Seq<Boolean>	wrap(boolean[] array)
static Seq<Byte>	wrap(byte[] array)
static Seq<Character>	wrap(char[] array)
static Seq<Double>	wrap(double[] array)
static Seq<Float>	wrap(float[] array)
static Seq<Integer>	wrap(int[] array)
static Seq<Long>	wrap(long[] array)
static Seq<Short>	wrap(short[] array)
static <E> Seq<E>	wrap(E[] array)
static Seq<Boolean>	wrap(Boolean[] array)
static Seq<Byte>	wrap(Byte[] array)
static Seq<Character>	wrap(Character[] array)
static Seq<Double>	wrap(Double[] array)
static Seq<Float>	wrap(Float[] array)
static Seq<Integer>	wrap(Integer[] array)
static Seq<Long>	wrap(Long[] array)
static Seq<Short>	wrap(Short[] array)
static Seq<Character>	wrap(String string)
static Seq<Boolean>	wrap(BitSet bitSet)
static <E> Seq<E>	wrap(List<E> list)
<A> Seq<Pair<E,A>>	zip(Seq<A> a)
static <A, B, C> Seq<Pair<A,B>>	zip(Seq<A> as, Seq<B> bs)
static <A, B, C> Seq<Triple<A,B,C>>	zip(Seq<A> as, Seq<B> bs, Seq<C> cs)
static <A, B, C, D> Seq<Quadruple<A,B,C,D>>	zip(Seq<A> as, Seq<B> bs, Seq<C> cs, Seq<D> ds)
<A, C> Seq<C>	zipWith(BiFunction<? super E,? super A,? extends C> function, Seq<A> sequence)
Seq<Pair<Integer,E>>	zipWithIndex()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface de.scravy.bedrock.Container

asString, draw, nonEmpty, stream

Methods inherited from interface de.scravy.bedrock.ExtendedIterable

forEachWithIndex, lengthAtLeast

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Details

serialVersionUID

public static final long serialVersionUID

See Also:

Constant Field Values

NULL_ACCEPTING_COMPARATOR

public static final Comparator<Object> NULL_ACCEPTING_COMPARATOR

Constructor Details

Seq

public Seq()

Method Details

get

public abstract E get(@Nonnegative int index)

apply

public E apply(@Nonnegative int index)

Specified by:

apply in interface IntFunction<E>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Container<E>

shuffled

@Nonnull public Seq<E> shuffled(@Nonnull Random random)

draw

public E draw(@Nonnull Random random) throws NoSuchElementException

Specified by:

draw in interface Container<E>

Throws:

NoSuchElementException

sortedBy

@Nonnull public abstract Seq<E> sortedBy(@Nonnull Comparator<? super E> comparator)

sortedOn

@Nonnull public <F extends Comparable<? super F>> Seq<E> sortedOn(@Nonnull Function<? super E,? extends F> function)

toArray

@Nonnull public abstract E[] toArray(@Nonnull Class<E> clazz)

toArray

@Nonnull public abstract Object[] toArray()

asString

@Nonnull public String asString(@Nonnull String delimiter)

Specified by:

asString in interface Container<E>

count

@Nonnegative public int count(@Nullable E e)

countBy

@Nonnegative public int countBy(@Nonnull Predicate<? super E> predicate)

find

public int find(@Nullable E e)

findBy

public int findBy(@Nonnull Predicate<? super E> predicate)

findFirst

public Optional<E> findFirst(@Nonnull Predicate<? super E> predicate)

contains

public boolean contains(@Nullable E e)

Specified by:

contains in interface Container<E>

exists

public boolean exists(@Nonnull Predicate<? super E> predicate)

Specified by:

exists in interface Container<E>

forAll

public boolean forAll(@Nonnull Predicate<? super E> predicate)

Specified by:

forAll in interface Container<E>

map

@Nonnull public <F> Seq<F> map(@Nonnull Function<? super E,? extends F> function)

flatMap

@Nonnull public <F> Seq<F> flatMap(@Nonnull Function<? super E,Seq<F>> function)

flatMapOptional

@Nonnull public <F> Seq<F> flatMapOptional(@Nonnull Function<? super E,Optional<F>> function)

flatMapIterable

@Nonnull public <F> Seq<F> flatMapIterable(@Nonnull Function<? super E,? extends Iterable<F>> function)

zip

@Nonnull public <A> Seq<Pair<E,A>> zip(@Nonnull Seq<A> a)

zipWith

@Nonnull public <A, C> Seq<C> zipWith(@Nonnull BiFunction<? super E,? super A,? extends C> function, @Nonnull Seq<A> sequence)

zipWithIndex

@Nonnull public Seq<Pair<Integer,E>> zipWithIndex()

foldl

public <A> A foldl(@Nonnull BiFunction<? super A,? super E,? extends A> function, A startValue)

foldl1

public E foldl1(@Nonnull BiFunction<? super E,? super E,? extends E> function)

foldl1f

public <A> A foldl1f(@Nonnull BiFunction<? super A,? super E,? extends A> function, @Nonnull Function<? super E,? extends A> startValueFunction)

foldr

public <A> A foldr(@Nonnull BiFunction<? super E,? super A,? extends A> function, A startValue)

foldr1

public E foldr1(@Nonnull BiFunction<? super E,? super E,? extends E> function)

foldr1f

public <A> A foldr1f(@Nonnull BiFunction<? super E,? super A,? extends A> function, @Nonnull Function<? super E,? extends A> startValueFunction)

partitionBy

@Nonnull public Pair<Seq<E>,Seq<E>> partitionBy(@Nonnull Predicate<? super E> predicate)

maximum

public E maximum()

minimum

public E minimum()

maximumBy

public E maximumBy(Comparator<? super E> comparator)

minimumBy

public E minimumBy(Comparator<? super E> comparator)

group

@Nonnull public Seq<Seq<E>> group()

groupBy

@Nonnull public Seq<Seq<E>> groupBy(@Nonnull BiPredicate<? super E,? super E> operator)

filter

@Nonnull public <F extends E> Seq<F> filter(@Nonnull Class<F> clazz)

filter

@Nonnull public Seq<E> filter(@Nonnull Predicate<? super E> predicate)

filterNot

@Nonnull public Seq<E> filterNot(@Nonnull Predicate<? super E> predicate)

takeWhile

@Nonnull public Seq<E> takeWhile(@Nonnull Predicate<? super E> predicate)

takeWhileView

@Nonnull public Seq<E> takeWhileView(@Nonnull Predicate<? super E> predicate)

dropWhile

@Nonnull public Seq<E> dropWhile(@Nonnull Predicate<? super E> predicate)

dropWhileView

@Nonnull public Seq<E> dropWhileView(@Nonnull Predicate<? super E> predicate)

breakBy

@Nonnull public Pair<Seq<E>,Seq<E>> breakBy(@Nonnull Predicate<? super E> predicate)

breakByView

@Nonnull public Pair<Seq<E>,Seq<E>> breakByView(@Nonnull Predicate<? super E> predicate)

spanBy

@Nonnull public Pair<Seq<E>,Seq<E>> spanBy(@Nonnull Predicate<? super E> predicate)

spanByView

@Nonnull public Pair<Seq<E>,Seq<E>> spanByView(@Nonnull Predicate<? super E> predicate)

inits

@Nonnull public Seq<Seq<E>> inits()

initsView

@Nonnull public Seq<Seq<E>> initsView()

tails

@Nonnull public Seq<Seq<E>> tails()

tailsView

@Nonnull public Seq<Seq<E>> tailsView()

head

public E head()

last

public E last()

headOptional

@Nonnull public Optional<E> headOptional()

lastOptional

@Nonnull public Optional<E> lastOptional()

intercalate

@Nonnull public Seq<E> intercalate(@Nonnull Seq<E> seq)

intersperse

@Nonnull public Seq<E> intersperse(E e)

distinct

@Nonnull public Seq<E> distinct()

Returns a copy of this Seq with no duplicates.

Order is maintained.

without

public Seq<E> without(Seq<E> seq)

Returns a Seq with the elements from the given Seq removed.

Order is maintained, but the resuling Seq is not distinct; if this Seq contains duplicates then the result may contain duplicates too.

union

public Seq<E> union(Seq<E> seq)

Returns a distinct Seq that contains the elements from both this Seq and the given Seq.

Order is maintained, but there are no duplicates.

intersect

public Seq<E> intersect(Seq<E> seq)

Returns a distinct Seq that contains only the elements that occur in both sets.

Order is maintained.

equals

public boolean equals(@Nullable Object that)

Overrides:

equals in class Object

hashCode

public final int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object

rotated

@Nonnull public Seq<E> rotated(int amount)

Rotates the list by amount positions.

Positive values rotate items to the right, negative values to the left. Seq.of(1, 2, 3).rotated(1).equals(Seq.of(3, 1, 2)) Seq.of(1, 2, 3).rotated(-1).equals(Seq.of(2, 3, 1))

Parameters:

amount - The amount of positions to rotate, positive values to the right, negative values to the left.

Returns:

The rotated sequence.

permutationsIterator

@Nonnull public Iterator<Seq<E>> permutationsIterator()

permutations

@Nonnull public Seq<Seq<E>> permutations()

iterator

@Nonnull public Iterator<E> iterator()

Specified by:

iterator in interface Iterable<E>

reverseIterator

@Nonnull public Iterator<E> reverseIterator()

toList

@Nonnull public List<E> toList()

Create a java.util.List that contains the elements of this sequence.

This action does not copy any data.

Specified by:

toList in interface Container<E>

Returns:

An unmodifiable list that is backed by this Sequence.

collector

public static <T> Collector<T,SeqBuilder<T>,Seq<T>> collector()

toMap

@Nonnull public <K> Mapping<K,Seq<E>> toMap(@Nonnull Function<? super E,? extends K> groupingFunction)

toArrayMap

@Nonnull public <K extends Comparable<K>> ArrayMap<K,Seq<E>> toArrayMap(@Nonnull Function<? super E,? extends K> groupingFunction)

empty

@Nonnull public static <E> Seq<E> empty()

of

@SafeVarargs @Nonnull public static <E> Seq<E> of(@Nonnull E... es)

seq

@SafeVarargs @Nonnull public static <E> Seq<E> seq(@Nonnull E... es)

ofArray

@Nonnull public static <E> Seq<E> ofArray(@Nonnull E[] array)

ofCollection

@Nonnull public static <E> Seq<E> ofCollection(@Nonnull Collection<? extends E> collection)

ofIterable

@Nonnull public static <E> Seq<E> ofIterable(@Nonnull Iterable<? extends E> iterable)

ofIterator

@Nonnull public static <E> Seq<E> ofIterator(@Nonnull Iterator<? extends E> iterator)

ofPair

@Nonnull public static <C, A extends C, B extends C> Seq<C> ofPair(@Nonnull Pair<A,B> pair)

ofString

@Nonnull public static Seq<Character> ofString(@Nonnull String string)

codepointsOfString

@Nonnull public static Seq<Integer> codepointsOfString(@Nonnull String string)

concatView

@SafeVarargs @Nonnull public static <E> Seq<E> concatView(@Nonnull Seq<E>... seqs)

concat

@SafeVarargs @Nonnull public static <E> Seq<E> concat(@Nonnull Seq<E>... seqs)

builder

@Nonnull public static <E> SeqBuilder<E> builder()

builder

@Nonnull public static <E> SeqBuilder<E> builder(int sizeHint)

ofGenerator

@Nonnull public static <E> Seq<E> ofGenerator(@Nonnull IntFunction<E> function, @Nonnegative int length)

ofGeneratorMemoizing

@Nonnull public static <E> Seq<E> ofGeneratorMemoizing(@Nonnull IntFunction<E> function, @Nonnegative int length)

wrap

@Nonnull public static Seq<Character> wrap(@Nonnull char[] array)

wrap

@Nonnull public static Seq<Boolean> wrap(@Nonnull boolean[] array)

wrap

@Nonnull public static Seq<Byte> wrap(@Nonnull byte[] array)

wrap

@Nonnull public static Seq<Short> wrap(@Nonnull short[] array)

wrap

@Nonnull public static Seq<Integer> wrap(@Nonnull int[] array)

wrap

@Nonnull public static Seq<Long> wrap(@Nonnull long[] array)

wrap

@Nonnull public static Seq<Float> wrap(@Nonnull float[] array)

wrap

@Nonnull public static Seq<Double> wrap(@Nonnull double[] array)

wrap

@Nonnull public static Seq<Character> wrap(@Nonnull Character[] array)

wrap

@Nonnull public static Seq<Boolean> wrap(@Nonnull Boolean[] array)

wrap

@Nonnull public static Seq<Byte> wrap(@Nonnull Byte[] array)

wrap

@Nonnull public static Seq<Short> wrap(@Nonnull Short[] array)

wrap

@Nonnull public static Seq<Integer> wrap(@Nonnull Integer[] array)

wrap

@Nonnull public static Seq<Long> wrap(@Nonnull Long[] array)

wrap

@Nonnull public static Seq<Float> wrap(@Nonnull Float[] array)

wrap

@Nonnull public static Seq<Double> wrap(@Nonnull Double[] array)

wrap

@Nonnull public static <E> Seq<E> wrap(@Nonnull E[] array)

wrap

@Nonnull public static <E> Seq<E> wrap(@Nonnull List<E> list)

wrap

@Nonnull public static Seq<Boolean> wrap(@Nonnull BitSet bitSet)

wrap

@Nonnull public static Seq<Character> wrap(@Nonnull String string)

minimum

public static <E extends Comparable<? super E>> E minimum(Seq<E> seq)

maximum

public static <E extends Comparable<? super E>> E maximum(Seq<E> seq)

any

public static boolean any(@Nonnull Seq<Boolean> seq)

all

public static boolean all(@Nonnull Seq<Boolean> seq)

intSum

public static int intSum(Seq<Integer> seq)

longSum

public static long longSum(Seq<Long> seq)

doubleSum

public static double doubleSum(Seq<Double> seq)

intProduct

public static int intProduct(Seq<Integer> seq)

longProduct

public static long longProduct(Seq<Long> seq)

doubleProduct

public static double doubleProduct(Seq<Double> seq)

and

public static boolean and(Seq<Boolean> seq)

or

public static boolean or(Seq<Boolean> seq)

commonPrefixLength

public static <A, B> int commonPrefixLength(@Nonnull Seq<A> as, @Nonnull Seq<B> bs)

commonPrefix

@Nonnull public static <E, A extends E, B extends E> Seq<A> commonPrefix(Seq<A> as, Seq<B> bs)

commonPrefixView

@Nonnull public static <E, A extends E, B extends E> Seq<A> commonPrefixView(Seq<A> as, Seq<B> bs)

rangeInclusive

@Nonnull public static Seq<Integer> rangeInclusive(int from, int to)

rangeExclusive

@Nonnull public static Seq<Integer> rangeExclusive(int from, int to)

zip

public static <A, B, C, D> Seq<Quadruple<A,B,C,D>> zip(Seq<A> as, Seq<B> bs, Seq<C> cs, Seq<D> ds)

zip

public static <A, B, C> Seq<Triple<A,B,C>> zip(Seq<A> as, Seq<B> bs, Seq<C> cs)

zip

public static <A, B, C> Seq<Pair<A,B>> zip(Seq<A> as, Seq<B> bs)

length

@Nonnegative public abstract int length()

reversed

@Nonnull public abstract Seq<E> reversed()

sorted

@Nonnull public abstract Seq<E> sorted()

trimmedToSize

@Nonnull public abstract Seq<E> trimmedToSize()

subSequence

@Nonnull public abstract Seq<E> subSequence(@Nonnegative int beginOffset, @Nonnegative int endOffset)

subSequenceView

@Nonnull public abstract Seq<E> subSequenceView(@Nonnegative int beginOffset, @Nonnegative int endOffset)

size

@Nonnegative public default int size()

Exactly the same as length().

startsWith

public default boolean startsWith(@Nonnull Seq<E> sequence)

endsWith

public default boolean endsWith(@Nonnull Seq<E> sequence)

shuffled

@Nonnull public default Seq<E> shuffled()

init

@Nonnull public default Seq<E> init()

initView

@Nonnull public default Seq<E> initView()

tail

@Nonnull public default Seq<E> tail()

tailView

@Nonnull public default Seq<E> tailView()

take

@Nonnull public default Seq<E> take(@Nonnegative int length)

takeView

@Nonnull public default Seq<E> takeView(@Nonnegative int length)

takeRight

@Nonnull public default Seq<E> takeRight(@Nonnegative int length)

takeRightView

@Nonnull public default Seq<E> takeRightView(@Nonnegative int length)

drop

@Nonnull public default Seq<E> drop(@Nonnegative int length)

dropView

@Nonnull public default Seq<E> dropView(@Nonnegative int length)

dropRight

@Nonnull public default Seq<E> dropRight(@Nonnegative int length)

dropRightView

@Nonnull public default Seq<E> dropRightView(@Nonnegative int length)

permutationsIterable

@Nonnull public default Iterable<Seq<E>> permutationsIterable()

permutationsStream

@Nonnull public default Stream<Seq<E>> permutationsStream()