Uses of Class
de.scravy.bedrock.Seq

Packages that use Seq

Package	Description
de.scravy.bedrock

Uses of Seq in de.scravy.bedrock

Methods in de.scravy.bedrock that return Seq

Modifier and Type	Method	Description
static Seq<Integer>	Seq.codepointsOfString(String string)
static <E, A extends E, B extends E> Seq<A>	Seq.commonPrefix(Seq<A> as, Seq<B> bs)
static <E, A extends E, B extends E> Seq<A>	Seq.commonPrefixView(Seq<A> as, Seq<B> bs)
static <E> Seq<E>	Seq.concat(Seq<E>... seqs)
static <E> Seq<E>	Seq.concatView(Seq<E>... seqs)
Seq<LocalDate>	DateTimes.Interval.decomposeIntoDays()
Seq<E>	Seq.distinct()	Returns a copy of this Seq with no duplicates.
Seq<E>	Seq.dropWhile(Predicate<? super E> predicate)
Seq<E>	Seq.dropWhileView(Predicate<? super E> predicate)
Seq<Pair<V,V>>	DirectedGraph.edges()
static <E> Seq<E>	Seq.empty()
static Seq<String>	Strings.explode(String string, String delimiter)
<F extends E> Seq<F>	Seq.filter(Class<F> clazz)
Seq<E>	Seq.filter(Predicate<? super E> predicate)
Seq<E>	Seq.filterNot(Predicate<? super E> predicate)
<F> Seq<F>	Seq.flatMap(Function<? super E,Seq<F>> function)
<F> Seq<F>	Seq.flatMapIterable(Function<? super E,? extends Iterable<F>> function)
<F> Seq<F>	Seq.flatMapOptional(Function<? super E,Optional<F>> function)
static Seq<Class<?>>	Reflections.getParents(Class<?> clazz)
abstract Seq<Character>	CharParser.Result.getRemaining()
abstract Seq<?>	Parser.Result.getRemaining()
Seq<Seq<E>>	Seq.group()
Seq<Seq<E>>	Seq.groupBy(BiPredicate<? super E,? super E> operator)
Seq<Seq<E>>	Seq.inits()
Seq<Seq<E>>	Seq.initsView()
Seq<E>	Seq.intercalate(Seq<E> seq)
Seq<E>	Seq.intersect(Seq<E> seq)	Returns a distinct Seq that contains only the elements that occur in both sets.
Seq<E>	Seq.intersperse(E e)
Seq<K>	ArrayMap.keys()
Seq<K>	Mapping.EmptyMapping.keys()
Seq<From>	Mapping.keys()
<F> Seq<F>	Seq.map(Function<? super E,? extends F> function)
static <E> Seq<E>	Seq.of(E... es)
static <E> Seq<E>	Seq.ofArray(E[] array)
static <E> Seq<E>	Seq.ofCollection(Collection<? extends E> collection)
static <E> Seq<E>	Seq.ofGenerator(IntFunction<E> function, int length)
static <E> Seq<E>	Seq.ofGeneratorMemoizing(IntFunction<E> function, int length)
static <E> Seq<E>	Seq.ofIterable(Iterable<? extends E> iterable)
static <E> Seq<E>	Seq.ofIterator(Iterator<? extends E> iterator)
static <C, A extends C, B extends C> Seq<C>	Seq.ofPair(Pair<A,B> pair)
static Seq<Character>	Seq.ofString(String string)
static <T> Seq<T>	Control.parallel(Executor executor, Callable<? extends T>... runnables)
Seq<Seq<E>>	Seq.permutations()
static Seq<Integer>	Seq.rangeExclusive(int from, int to)
static Seq<Integer>	Seq.rangeInclusive(int from, int to)
Seq<E>	SeqBuilder.result()
Seq<E>	Seq.rotated(int amount)	Rotates the list by amount positions.
static <E> Seq<E>	Seq.seq(E... es)
Seq<E>	Seq.shuffled(Random random)
abstract Seq<E>	Seq.sortedBy(Comparator<? super E> comparator)
<F extends Comparable<? super F>> Seq<E>	Seq.sortedOn(Function<? super E,? extends F> function)
static <V> Seq<Seq<V>>	Graphs.stronglyConnectedComponents(DirectedGraph<V> graph)
static <V> Seq<Seq<V>>	Graphs.stronglyConnectedComponents(Seq<Pair<V,V>> edges)
Seq<Seq<E>>	Seq.tails()
Seq<Seq<E>>	Seq.tailsView()
Seq<E>	Seq.takeWhile(Predicate<? super E> predicate)
Seq<E>	Seq.takeWhileView(Predicate<? super E> predicate)
static <C, A extends C, B extends C> Seq<C>	Pair.toSeq(Tuple2<A,B> pair)
static <E, A extends E, B extends E, C extends E, D extends E> Seq<E>	Quadruple.toSeq(Tuple4<A,B,C,D> quadruple)
Seq<E>	Set.toSeq()	Cost: O(1) - The underlying structure is already a Seq
static <D, A extends D, B extends D, C extends D> Seq<D>	Triple.toSeq(Tuple3<A,B,C> triple)
default Seq<Object>	Tuple2.toSeq()
static <C, A extends C, B extends C> Seq<C>	Tuple2.toSeq(Tuple2<A,B> pair)
default Seq<Object>	Tuple3.toSeq()
default Seq<Object>	Tuple4.toSeq()
Seq<E>	Seq.union(Seq<E> seq)	Returns a distinct Seq that contains the elements from both this Seq and the given Seq.
Seq<V>	ArrayMap.values()
default Seq<To>	Mapping.values()
Seq<V>	DirectedGraph.vertices()
Seq<E>	Seq.without(Seq<E> seq)	Returns a Seq with the elements from the given Seq removed.
static Seq<Boolean>	Seq.wrap(boolean[] array)
static Seq<Byte>	Seq.wrap(byte[] array)
static Seq<Character>	Seq.wrap(char[] array)
static Seq<Double>	Seq.wrap(double[] array)
static Seq<Float>	Seq.wrap(float[] array)
static Seq<Integer>	Seq.wrap(int[] array)
static Seq<Long>	Seq.wrap(long[] array)
static Seq<Short>	Seq.wrap(short[] array)
static <E> Seq<E>	Seq.wrap(E[] array)
static Seq<Boolean>	Seq.wrap(Boolean[] array)
static Seq<Byte>	Seq.wrap(Byte[] array)
static Seq<Character>	Seq.wrap(Character[] array)
static Seq<Double>	Seq.wrap(Double[] array)
static Seq<Float>	Seq.wrap(Float[] array)
static Seq<Integer>	Seq.wrap(Integer[] array)
static Seq<Long>	Seq.wrap(Long[] array)
static Seq<Short>	Seq.wrap(Short[] array)
static Seq<Character>	Seq.wrap(String string)
static Seq<Boolean>	Seq.wrap(BitSet bitSet)
static <E> Seq<E>	Seq.wrap(List<E> list)
<A> Seq<Pair<E,A>>	Seq.zip(Seq<A> a)
static <A, B, C> Seq<Pair<A,B>>	Seq.zip(Seq<A> as, Seq<B> bs)
static <A, B, C> Seq<Triple<A,B,C>>	Seq.zip(Seq<A> as, Seq<B> bs, Seq<C> cs)
static <A, B, C, D> Seq<Quadruple<A,B,C,D>>	Seq.zip(Seq<A> as, Seq<B> bs, Seq<C> cs, Seq<D> ds)
<A, C> Seq<C>	Seq.zipWith(BiFunction<? super E,? super A,? extends C> function, Seq<A> sequence)
Seq<Pair<Integer,E>>	Seq.zipWithIndex()

Methods in de.scravy.bedrock that return types with arguments of type Seq

Modifier and Type	Method	Description
Pair<Seq<E>,Seq<E>>	Seq.breakBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.breakBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.breakByView(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.breakByView(Predicate<? super E> predicate)
static <T> Collector<T,SeqBuilder<T>,Seq<T>>	Seq.collector()
Seq<Seq<E>>	Seq.group()
Seq<Seq<E>>	Seq.groupBy(BiPredicate<? super E,? super E> operator)
Seq<Seq<E>>	Seq.inits()
Seq<Seq<E>>	Seq.initsView()
static <T> CharParser<Seq<T>>	CharParser.many(CharParser<T> parser)
static <T> Parser<Seq<T>>	Parser.many(Parser<T> parser)
static <T> CharParser<Seq<T>>	CharParser.many1(CharParser<T> parser)
static <T> Parser<Seq<T>>	Parser.many1(Parser<T> parser)
static <T> ThrowingConsumer<Callback<Seq<T>>>	Control.parallel(ThrowingConsumer<Callback<T>>... actions)
Pair<Seq<E>,Seq<E>>	Seq.partitionBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.partitionBy(Predicate<? super E> predicate)
Seq<Seq<E>>	Seq.permutations()
Iterator<Seq<E>>	Seq.permutationsIterator()
static <T, U> CharParser<Seq<T>>	CharParser.sepBy(CharParser<T> parser, CharParser<U> sep)
static <T, U> Parser<Seq<T>>	Parser.sepBy(Parser<T> parser, Parser<U> sep)
static <T, U> CharParser<Seq<T>>	CharParser.sepBy1(CharParser<T> parser, CharParser<U> sep)
static <T, U> Parser<Seq<T>>	Parser.sepBy1(Parser<T> parser, Parser<U> sep)
static <T> CharParser<Seq<T>>	CharParser.sequence(CharParser<T>... parsers)
static <T> CharParser<Seq<T>>	CharParser.sequence(Iterable<CharParser<T>> parsers)
static <T> Parser<Seq<T>>	Parser.sequence(Parser<T>... ps)
static <T> Parser<Seq<T>>	Parser.sequence(Iterable<Parser<T>> ps)
Pair<Seq<E>,Seq<E>>	Seq.spanBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.spanBy(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.spanByView(Predicate<? super E> predicate)
Pair<Seq<E>,Seq<E>>	Seq.spanByView(Predicate<? super E> predicate)
static <V> Seq<Seq<V>>	Graphs.stronglyConnectedComponents(DirectedGraph<V> graph)
static <V> Seq<Seq<V>>	Graphs.stronglyConnectedComponents(Seq<Pair<V,V>> edges)
Seq<Seq<E>>	Seq.tails()
Seq<Seq<E>>	Seq.tailsView()
<T> Control.Async<In,Seq<T>>	Control.Async.then(ThrowingBiConsumer<Out,Callback<T>> function, ThrowingBiConsumer<Out,Callback<T>>... functions)
static <T> CharParser<Seq<T>>	CharParser.times(int n, CharParser<T> parser)
static <T> Parser<Seq<T>>	Parser.times(int n, Parser<T> p)
<K extends Comparable<K>> ArrayMap<K,Seq<E>>	Seq.toArrayMap(Function<? super E,? extends K> groupingFunction)
<K> Mapping<K,Seq<E>>	Seq.toMap(Function<? super E,? extends K> groupingFunction)
static <V> Optional<Seq<V>>	Graphs.topologicalSort(Seq<Pair<V,V>> edges)

Methods in de.scravy.bedrock with parameters of type Seq

Modifier and Type	Method	Description
<K> MultiValuedKeyMap.Builder<T>	MultiValuedKeyMap.Builder.add(Seq<K> key, T value)
static boolean	Seq.all(Seq<Boolean> seq)
static boolean	Seq.and(Seq<Boolean> seq)
static boolean	Seq.any(Seq<Boolean> seq)
T	MultiValuedKeyMap.apply(Seq<Object> key)
static <E, A extends E, B extends E> Seq<A>	Seq.commonPrefix(Seq<A> as, Seq<B> bs)
static <A, B> int	Seq.commonPrefixLength(Seq<A> as, Seq<B> bs)
static <E, A extends E, B extends E> Seq<A>	Seq.commonPrefixView(Seq<A> as, Seq<B> bs)
static <E> Seq<E>	Seq.concat(Seq<E>... seqs)
static <E> Seq<E>	Seq.concatView(Seq<E>... seqs)
static double	Seq.doubleProduct(Seq<Double> seq)
static double	Seq.doubleSum(Seq<Double> seq)
static <V> DirectedGraph<V>	DirectedGraph.fromEdges(Seq<Pair<V,V>> edges)
<K> Optional<T>	MultiValuedKeyMap.get(Seq<K> key)
<K> T	MultiValuedKeyMap.get(Seq<K> key, Supplier<T> fallbackSupplier)
<K> T	MultiValuedKeyMap.get(Seq<K> key, Supplier<T> fallbackSupplier, List<Object> trace)	Lookup a value in the map and trace the path taken to find it.
<K> T	MultiValuedKeyMap.get(Seq<K> key, T fallback)
<K> T	MultiValuedKeyMap.get(Seq<K> key, T fallback, List<Object> trace)	Lookup a value in the map and trace the path taken to find it.
Seq<E>	Seq.intercalate(Seq<E> seq)
Seq<E>	Seq.intersect(Seq<E> seq)	Returns a distinct Seq that contains only the elements that occur in both sets.
static int	Seq.intProduct(Seq<Integer> seq)
static int	Seq.intSum(Seq<Integer> seq)
static long	Seq.longProduct(Seq<Long> seq)
static long	Seq.longSum(Seq<Long> seq)
static <E extends Comparable<? super E>> E	Seq.maximum(Seq<E> seq)
static <E extends Comparable<? super E>> E	Seq.minimum(Seq<E> seq)
static <K extends Comparable<K>, V> ArrayMap<K,V>	ArrayMap.ofSeq(Seq<Pair<K,V>> pairs)
static <E extends Comparable<? super E>> Set<E>	Set.ofSeq(Seq<E> elements)
static boolean	Seq.or(Seq<Boolean> seq)
CharParser.Result<T>	CharParser.parse(Seq<Character> seq)
Parser.Result<T>	Parser.parse(Seq<?> seq)
static <V> Seq<Seq<V>>	Graphs.stronglyConnectedComponents(Seq<Pair<V,V>> edges)
static <V> Optional<Seq<V>>	Graphs.topologicalSort(Seq<Pair<V,V>> edges)
Seq<E>	Seq.union(Seq<E> seq)	Returns a distinct Seq that contains the elements from both this Seq and the given Seq.
static <A> Control.Async<A,A>	Control.waterfall(Seq<ThrowingBiConsumer<A,Callback<A>>> fs)
Seq<E>	Seq.without(Seq<E> seq)	Returns a Seq with the elements from the given Seq removed.
abstract CharParser.Result<E>	CharParser.Result.withRemaining(Seq<Character> seq)
abstract Parser.Result<E>	Parser.Result.withRemaining(Seq<?> seq)
<A> Seq<Pair<E,A>>	Seq.zip(Seq<A> a)
static <A, B, C> Seq<Pair<A,B>>	Seq.zip(Seq<A> as, Seq<B> bs)
static <A, B, C> Seq<Triple<A,B,C>>	Seq.zip(Seq<A> as, Seq<B> bs, Seq<C> cs)
static <A, B, C, D> Seq<Quadruple<A,B,C,D>>	Seq.zip(Seq<A> as, Seq<B> bs, Seq<C> cs, Seq<D> ds)
<A, C> Seq<C>	Seq.zipWith(BiFunction<? super E,? super A,? extends C> function, Seq<A> sequence)

Method parameters in de.scravy.bedrock with type arguments of type Seq

Modifier and Type	Method	Description
<F> Seq<F>	Seq.flatMap(Function<? super E,Seq<F>> function)
static <T> T	Reflections.proxy(Class<T> clazz, ThrowingBiFunction<String,Seq<Object>,Object> handler)
static <T, U> Parser<U>	Parser.recurse(Class<T> clazz, Predicate<T> predicate, Function<T,Seq<?>> extractor, Parser<U> parser)
static <T, U> Parser<U>	Parser.recurse2(Class<T> clazz, Function<T,Seq<?>> extractor, Function<T,Parser<U>> parser)

Constructors in de.scravy.bedrock with parameters of type Seq

Constructor	Description
ParallelExecutionException(Seq<Throwable> causes)