Uses of Class com.m3.scalaflavor4j.Seq (scalaflavor4j 1.1.8 API)

Packages that use Seq
Package Description

com.m3.scalaflavor4j

Packages that use Seq
Package	Description
com.m3.scalaflavor4j

Uses of Seq in com.m3.scalaflavor4j

Subclasses of Seq in com.m3.scalaflavor4j
Modifier and Type	Class and Description
`class`	`IndexedSeq<T>` `Seq` implementation
`class`	`Nil<T>` `Seq` implementation
`class`	`StringLike` scala.collection.immutable.StringLike

Fields in com.m3.scalaflavor4j declared as Seq
Modifier and Type	Field and Description
`protected Seq<Class<? extends Throwable>>`	ExceptionControl.CatchBuilder.`classesToCatch`

Methods in com.m3.scalaflavor4j that return Seq
Modifier and Type	Method and Description
`abstract Seq<T>`	Seq.`append(T... that)` [Original] Appends the passed elements This method is similar to scala.collectoin.Seq#+:(A)
`Seq<T>`	Nil.`append(T... that)`
`static <T> Seq<T>`	Seq.`apply(Enumeration<T> e)`
`static <T> Seq<T>`	Seq.`apply(Iterable<T> iterable)`
`static <T> Seq<T>`	Seq.`apply(Iterator<T> iter)`
`static <T> Seq<T>`	Seq.`apply(T... values)`
`protected static <T> Seq<T>`	Seq.`applyCollection(Collection<T> col)`
`abstract Seq<T>`	Seq.`diff(Seq<T> that)` Computes the multiset difference between this sequence and another sequence.
`Seq<T>`	Nil.`diff(Seq<T> that)`
`abstract Seq<T>`	Seq.`distinct()` Builds a new sequence from this sequence without any duplicate elements.
`Seq<T>`	Nil.`distinct()`
`abstract Seq<T>`	Seq.`drop(int n)` Selects all elements except first n ones.
`Seq<T>`	Nil.`drop(int n)`
`abstract Seq<T>`	Seq.`dropNull()` [Original] Drops null elements
`Seq<T>`	Nil.`dropNull()`
`Seq<T>`	IndexedSeq.`dropNull()`
`abstract Seq<T>`	Seq.`dropRight(int n)` Selects all elements except last n ones.
`Seq<T>`	Nil.`dropRight(int n)`
`abstract Seq<T>`	Seq.`dropWhile(Function1<T,Boolean> p)` Drops longest prefix of elements that satisfy a predicate.
`Seq<T>`	Nil.`dropWhile(Function1<T,Boolean> p)`
`abstract Seq<T>`	Seq.`filter(Function1<T,Boolean> f)` Selects all elements of this sequence which satisfy a predicate.
`Seq<T>`	Nil.`filter(Function1<T,Boolean> f)`
`abstract Seq<T>`	Seq.`filterNot(Function1<T,Boolean> f)` Selects all elements of this immutable sequence which do not satisfy a predicate.
`Seq<T>`	Nil.`filterNot(Function1<T,Boolean> f)`
`abstract <U> Seq<U>`	Seq.`flatMap(Function1<T,CollectionLike<U>> f)` Builds a new collection by applying a function to all elements of this sequence and concatenating the results.
`<U> Seq<U>`	Nil.`flatMap(Function1<T,CollectionLike<U>> f)`
`Seq<CaseClause<?,R>>`	PartialFunction.`getCaseClauses()`
`Seq<String>`	BufferedSource.`getLines()` Reads input lines
`abstract Seq<Integer>`	Seq.`indices()` Produces the range of all indices of this sequence.
`Seq<Integer>`	Nil.`indices()`
`Seq<Integer>`	IndexedSeq.`indices()`
`abstract Seq<T>`	Seq.`init()` Selects all elements except the last.
`Seq<T>`	Nil.`init()`
`Seq<T>`	IndexedSeq.`init()`
`abstract Seq<T>`	Seq.`intersect(Seq<T> that)` Computes the multiset intersection between this sequence and another sequence.
`Seq<T>`	Nil.`intersect(Seq<T> that)`
`abstract <U> Seq<U>`	Seq.`map(Function1<T,U> f)` Builds a new collection by applying a function to all elements of this sequence.
`<U> Seq<U>`	Nil.`map(Function1<T,U> f)`
`abstract Seq<T>`	Seq.`padTo(int len, T elem)` Appends an element value to this sequence until a given target length is reached.
`Seq<T>`	Nil.`padTo(int len, T elem)`
`abstract Seq<T>`	Seq.`patch(int from, Seq<T> patch, int replaced)` Produces a new sequence where a slice of elements in this sequence is replaced by another sequence.
`Seq<T>`	Nil.`patch(int from, Seq<T> patch, int replaced)`
`abstract Seq<T>`	Seq.`reverse()` Returns new sequence wih elements in reversed order.
`Seq<T>`	Nil.`reverse()`
`abstract <U> Seq<U>`	Seq.`reverseMap(Function1<T,U> f)` Builds a new collection by applying a function to all elements of this sequence and collecting the results in reversed order.
`<U> Seq<U>`	Nil.`reverseMap(Function1<T,U> f)`
`Seq<String>`	Process.`runAndGetStdout()` scala.sys.process.ProcessBuilder#!! Starts the process represented by this builder, blocks until it exits, and returns the output as a String.
`abstract <U> Seq<U>`	Seq.`scanLeft(U z, Function2<U,T,U> op)` Produces a collection containing cummulative results of applying the operator going left to right.
`<U> Seq<U>`	Nil.`scanLeft(U z, Function2<U,T,U> op)`
`abstract <U> Seq<U>`	Seq.`scanRight(U z, Function2<T,U,U> op)` Produces a collection containing cummulative results of applying the operator going right to left.
`<U> Seq<U>`	Nil.`scanRight(U z, Function2<T,U,U> op)`
`static <T> Seq<T>`	Predef.`seq(Enumeration<T> e)`
`static <T> Seq<T>`	Predef.`seq(Iterable<T> iterable)`
`static <T> Seq<T>`	Predef.`seq(Iterator<T> iter)`
`static <T> Seq<T>`	Predef.`seq(T... values)`
`abstract Seq<T>`	Seq.`slice(int from, int until)` Selects an interval of elements.
`Seq<T>`	Nil.`slice(int from, int until)`
`abstract Seq<Seq<T>>`	Seq.`sliding(int size)` Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
`Seq<Seq<T>>`	Nil.`sliding(int size)`
`abstract Seq<Seq<T>>`	Seq.`sliding(int size, int step)` Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
`Seq<Seq<T>>`	Nil.`sliding(int size, int step)`
`abstract Seq<T>`	Seq.`sortWith(Function2<T,T,Boolean> lt)` Sorts this sequence according to a comparison function.
`Seq<T>`	Nil.`sortWith(Function2<T,T,Boolean> lt)`
`abstract Seq<T>`	Seq.`tail()` Selects all elements except the first.
`Seq<T>`	Nil.`tail()`
`abstract Seq<T>`	Seq.`take(int n)` Selects first n elements.
`Seq<T>`	Nil.`take(int n)`
`abstract Seq<T>`	Seq.`takeRight(int n)` Selects last n elements.
`Seq<T>`	Nil.`takeRight(int n)`
`abstract Seq<T>`	Seq.`takeWhile(Function1<T,Boolean> p)` Takes longest prefix of elements that satisfy a predicate.
`Seq<T>`	Nil.`takeWhile(Function1<T,Boolean> p)`
`Seq<Byte>`	BufferedSource.`toByteSeq()` Reads as a byte list
`Seq<Character>`	BufferedSource.`toCharSeq()` Reads as a char list
`Seq<Tuple2<K,V>>`	SMap.`toSeq()`
`abstract Seq<T>`	ParSeq.`toSeq()` Converts to `Seq`
`Seq<T>`	ForkJoinParSeq.`toSeq()`
`Seq<String>`	BufferedSource.`toStringSeq()` Reads as a string list
`abstract Seq<T>`	Seq.`transpose()` Transposes this list of traversable collections into a list of lists.
`Seq<T>`	Nil.`transpose()`
`Seq<T>`	IndexedSeq.`transpose()`
`abstract Seq<T>`	Seq.`union(Seq<T> that)` Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence.
`Seq<T>`	Nil.`union(Seq<T> that)`
`abstract Seq<T>`	Seq.`updated(int index, T elem)` A copy of this sequence with one single replaced element.
`Seq<T>`	Nil.`updated(int index, T elem)`
`Seq<T>`	IndexedSeq.`updated(int index, T elem)`
`abstract <U> Seq<Tuple2<T,U>>`	Seq.`zip(Seq<U> that)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<U> Seq<Tuple2<T,U>>`	Nil.`zip(Seq<U> that)`
`abstract Seq<Tuple2<T,Integer>>`	Seq.`zipWithIndex()` Zips this sequence with its indices.
`Seq<Tuple2<T,Integer>>`	Nil.`zipWithIndex()`

Methods in com.m3.scalaflavor4j that return types with arguments of type Seq
Modifier and Type	Method and Description
`abstract <U> SMap<U,Seq<T>>`	Seq.`groupBy(Function1<T,U> f)` Partitions this sequence into a map of sequences according to some discriminator function.
`abstract <U> SMap<U,Seq<T>>`	ParSeq.`groupBy(Function1<T,U> f)` Partitions this sequence into a map of sequences according to some discriminator function.
`<U> SMap<U,Seq<T>>`	Nil.`groupBy(Function1<T,U> f)`
`<U> SMap<U,Seq<T>>`	IndexedSeq.`groupBy(Function1<T,U> getGroupName)`
`<U> SMap<U,Seq<T>>`	ForkJoinParSeq.`groupBy(Function1<T,U> getGroupName)`
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`partition(Function1<T,Boolean> p)` Partitions this sequence in two sequences according to a predicate.
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`partition(Function1<T,Boolean> p)` Partitions this sequence in two sequences according to a predicate.
`Tuple2<Seq<T>,Seq<T>>`	Nil.`partition(Function1<T,Boolean> p)`
`Tuple2<Seq<T>,Seq<T>>`	Nil.`partition(Function1<T,Boolean> p)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`partition(Function1<T,Boolean> predicate)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`partition(Function1<T,Boolean> predicate)`
`abstract <U> Function1<Function2<U,T,U>,Seq<U>>`	Seq.`scanLeft(U z)` Curried `scanLeft(Object, Function2)`
`<U> Function1<Function2<U,T,U>,Seq<U>>`	Nil.`scanLeft(U z)`
`<U> Function1<Function2<U,T,U>,Seq<U>>`	IndexedSeq.`scanLeft(U z)`
`abstract <U> Function1<Function2<T,U,U>,Seq<U>>`	Seq.`scanRight(U z)` Curried `scanRight(Object, Function2)`
`<U> Function1<Function2<T,U,U>,Seq<U>>`	Nil.`scanRight(U z)`
`<U> Function1<Function2<T,U,U>,Seq<U>>`	IndexedSeq.`scanRight(U z)`
`abstract Seq<Seq<T>>`	Seq.`sliding(int size)` Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
`Seq<Seq<T>>`	Nil.`sliding(int size)`
`IndexedSeq<Seq<T>>`	IndexedSeq.`sliding(int size)`
`abstract Seq<Seq<T>>`	Seq.`sliding(int size, int step)` Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
`Seq<Seq<T>>`	Nil.`sliding(int size, int step)`
`IndexedSeq<Seq<T>>`	IndexedSeq.`sliding(int blockSize, int step)`
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`span(Function1<T,Boolean> p)` Splits this sequence into a prefix/suffix pair according to a predicate.
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`span(Function1<T,Boolean> p)` Splits this sequence into a prefix/suffix pair according to a predicate.
`Tuple2<Seq<T>,Seq<T>>`	Nil.`span(Function1<T,Boolean> p)`
`Tuple2<Seq<T>,Seq<T>>`	Nil.`span(Function1<T,Boolean> p)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`span(Function1<T,Boolean> predicate)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`span(Function1<T,Boolean> predicate)`
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`splitAt(int n)` Splits this sequence into two at a given position.
`abstract Tuple2<Seq<T>,Seq<T>>`	Seq.`splitAt(int n)` Splits this sequence into two at a given position.
`Tuple2<Seq<T>,Seq<T>>`	Nil.`splitAt(int n)`
`Tuple2<Seq<T>,Seq<T>>`	Nil.`splitAt(int n)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`splitAt(int n)`
`Tuple2<Seq<T>,Seq<T>>`	IndexedSeq.`splitAt(int n)`
`Tuple2<Seq<K>,Seq<V>>`	SMap.`unzip()` Converts this immutable map of pairs into two collections of the first and second half of each pair.
`Tuple2<Seq<K>,Seq<V>>`	SMap.`unzip()` Converts this immutable map of pairs into two collections of the first and second half of each pair.

Methods in com.m3.scalaflavor4j with parameters of type Seq
Modifier and Type	Method and Description
`static <R> PartialF<R>`	PartialFunction.`apply(Seq<CaseClause<?,R>> caseClauses)`
`static <R> PartialF<R>`	PartialF.`apply(Seq<CaseClause<?,R>> caseClauses)`
`static <K,V> SMap<K,V>`	SMap.`apply(Seq<Tuple2<K,V>> tuples)`
`abstract <U> Function1<Function2<T,U,Boolean>,Boolean>`	Seq.`corresponds(Seq<U> that)` Curried `corresponds(Seq)`
`<U> Function1<Function2<T,U,Boolean>,Boolean>`	Nil.`corresponds(Seq<U> that)`
`<U> Function1<Function2<T,U,Boolean>,Boolean>`	IndexedSeq.`corresponds(Seq<U> that)`
`abstract <U> boolean`	Seq.`corresponds(Seq<U> that, Function2<T,U,Boolean> p)` Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate.
`<U> boolean`	Nil.`corresponds(Seq<U> that, Function2<T,U,Boolean> p)`
`<U> boolean`	IndexedSeq.`corresponds(Seq<U> that, Function2<T,U,Boolean> p)`
`abstract Seq<T>`	Seq.`diff(Seq<T> that)` Computes the multiset difference between this sequence and another sequence.
`Seq<T>`	Nil.`diff(Seq<T> that)`
`IndexedSeq<T>`	IndexedSeq.`diff(Seq<T> that)`
`abstract boolean`	Seq.`endsWith(Seq<T> that)` Tests whether this sequence ends with the given sequence.
`boolean`	Nil.`endsWith(Seq<T> that)`
`boolean`	IndexedSeq.`endsWith(Seq<T> that)`
`abstract Seq<T>`	Seq.`intersect(Seq<T> that)` Computes the multiset intersection between this sequence and another sequence.
`Seq<T>`	Nil.`intersect(Seq<T> that)`
`IndexedSeq<T>`	IndexedSeq.`intersect(Seq<T> that)`
`abstract Seq<T>`	Seq.`patch(int from, Seq<T> patch, int replaced)` Produces a new sequence where a slice of elements in this sequence is replaced by another sequence.
`Seq<T>`	Nil.`patch(int from, Seq<T> patch, int replaced)`
`IndexedSeq<T>`	IndexedSeq.`patch(int from, Seq<T> patch, int replaced)`
`abstract boolean`	Seq.`sameElements(Seq<T> that)` Checks if the other iterable collection contains the same elements in the same order as this sequence.
`boolean`	Nil.`sameElements(Seq<T> that)`
`boolean`	IndexedSeq.`sameElements(Seq<T> that)`
`abstract boolean`	Seq.`startsWith(Seq<T> that)` Tests whether this sequence contains the given sequence at a given index.
`boolean`	Nil.`startsWith(Seq<T> that)`
`boolean`	IndexedSeq.`startsWith(Seq<T> that)`
`abstract boolean`	Seq.`startsWith(Seq<T> that, int offset)` Tests whether this sequence contains the given sequence at a given index.
`boolean`	Nil.`startsWith(Seq<T> that, int offset)`
`boolean`	IndexedSeq.`startsWith(Seq<T> that, int offset)`
`abstract Seq<T>`	Seq.`union(Seq<T> that)` Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence.
`Seq<T>`	Nil.`union(Seq<T> that)`
`IndexedSeq<T>`	IndexedSeq.`union(Seq<T> that)`
`abstract <U> Seq<Tuple2<T,U>>`	Seq.`zip(Seq<U> that)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<U> Seq<Tuple2<T,U>>`	Nil.`zip(Seq<U> that)`
`<U> IndexedSeq<Tuple2<T,U>>`	IndexedSeq.`zip(Seq<U> that)`

Constructors in com.m3.scalaflavor4j with parameters of type Seq
Constructor and Description
`ExceptionControl.Catch(Seq<Class<? extends Throwable>> classes, Function1<Throwable,R> withApply)`
`ExceptionControl.Catch(Seq<Class<? extends Throwable>> classes, Function1<Throwable,R> withApply, boolean promiscuously)`
`ExceptionControl.Catch(Seq<com.m3.scalaflavor4j.ExceptionControl.Catch.HandlerDef> handlerDefinitions, boolean promiscuously)`
`ExceptionControl.CatchBuilder(Seq<Class<? extends Throwable>> classesToCatch)`
`ExceptionControl.HandlingByBuilder(Seq<Class<? extends Throwable>> classesToCatch)`

Uses of Classcom.m3.scalaflavor4j.Seq

Uses of Seq in com.m3.scalaflavor4j

Uses of Class
com.m3.scalaflavor4j.Seq