Seq (scalaflavor4j 1.1.8 API)

java.lang.Object
- com.m3.scalaflavor4j.Seq<T>

All Implemented Interfaces:

CollectionLike<T>, Serializable

Direct Known Subclasses:

IndexedSeq, Nil
```
public abstract class Seq<T>
extends Object
implements CollectionLike<T>
```
scala.collection.Seq

See Also:
"http://www.scala-lang.org/api/2.9.1/index.html#scala.collection.Seq", Serialized Form

Constructor Summary

Constructors
Constructor and Description

Seq()

Constructors
Constructor and Description
`Seq()`

Method Summary

Methods
Modifier and Type	Method and Description
`abstract Seq<T>`	`append(T... that)` [Original] Appends the passed elements This method is similar to scala.collectoin.Seq#+:(A)
`static <T> Seq<T>`	`apply(Enumeration<T> e)`
`static <T> Seq<T>`	`apply(Iterable<T> iterable)`
`static <T> Seq<T>`	`apply(Iterator<T> iter)`
`static <T> Seq<T>`	`apply(T... values)`
`protected static <T> Seq<T>`	`applyCollection(Collection<T> col)`
`abstract boolean`	`contains(T elem)` Tests whether this sequence contains a given value as an element.
`abstract <U> Function1<Function2<T,U,Boolean>,Boolean>`	`corresponds(Seq<U> that)` Curried `corresponds(Seq)`
`abstract <U> boolean`	`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.
`abstract int`	`count(Function1<T,Boolean> p)` Counts the number of elements in the sequence which satisfy a predicate.
`abstract Seq<T>`	`diff(Seq<T> that)` Computes the multiset difference between this sequence and another sequence.
`abstract Seq<T>`	`distinct()` Builds a new sequence from this sequence without any duplicate elements.
`abstract Seq<T>`	`drop(int n)` Selects all elements except first n ones.
`abstract Seq<T>`	`dropNull()` [Original] Drops null elements
`abstract Seq<T>`	`dropRight(int n)` Selects all elements except last n ones.
`abstract Seq<T>`	`dropWhile(Function1<T,Boolean> p)` Drops longest prefix of elements that satisfy a predicate.
`abstract boolean`	`endsWith(Seq<T> that)` Tests whether this sequence ends with the given sequence.
`abstract boolean`	`exists(Function1<T,Boolean> p)` Tests whether a predicate holds for some of the elements of this sequence.
`abstract Seq<T>`	`filter(Function1<T,Boolean> f)` Selects all elements of this sequence which satisfy a predicate.
`abstract Seq<T>`	`filterNot(Function1<T,Boolean> f)` Selects all elements of this immutable sequence which do not satisfy a predicate.
`abstract Option<T>`	`find(Function1<T,Boolean> p)` Finds the first element of the sequence satisfying a predicate, if any.
`abstract <U> Seq<U>`	`flatMap(Function1<T,CollectionLike<U>> f)` Builds a new collection by applying a function to all elements of this sequence and concatenating the results.
`abstract <U> Function1<Function2<U,T,U>,U>`	`foldLeft(U z)` Curried `foldLeft(Object, Function2)`
`abstract <U> U`	`foldLeft(U z, Function2<U,T,U> op)` Applies a binary operator to a start value and all elements of this sequence, going left to right.
`abstract <U> Function1<Function2<T,U,U>,U>`	`foldRight(U z)` Curried `foldRight(Object, Function2)`
`abstract <U> U`	`foldRight(U z, Function2<T,U,U> op)` Applies a binary operator to all elements of this sequence and a start value, going right to left.
`abstract boolean`	`forall(Function1<T,Boolean> p)` Tests whether a predicate holds for all elements of this sequence.
`abstract <U> SMap<U,Seq<T>>`	`groupBy(Function1<T,U> f)` Partitions this sequence into a map of sequences according to some discriminator function.
`abstract T`	`head()` Selects the first element of this sequence.
`abstract Option<T>`	`headOption()` Optionally selects the first element.
`abstract int`	`indexOf(T elem)` Finds index of first occurrence of some value in this sequence after or at some start index.
`abstract Seq<Integer>`	`indices()` Produces the range of all indices of this sequence.
`abstract Seq<T>`	`init()` Selects all elements except the last.
`abstract Seq<T>`	`intersect(Seq<T> that)` Computes the multiset intersection between this sequence and another sequence.
`abstract boolean`	`isDefinedAt(int idx)` Tests whether this sequence contains given index.
`abstract T`	`last()` Selects the last element.
`abstract Option<T>`	`lastOption()` Optionally selects the last element.
`abstract <U> Seq<U>`	`map(Function1<T,U> f)` Builds a new collection by applying a function to all elements of this sequence.
`abstract SNum`	`max()` Finds the largest element.
`abstract SNum`	`min()` Finds the smallest element.
`abstract String`	`mkString()` Displays all elements of this sequence in a string.
`abstract String`	`mkString(String sep)` Displays all elements of this sequence in a string using a separator string.
`abstract String`	`mkString(String start, String sep, String end)` Displays all elements of this sequence in a string using start, end, and separator strings.
`abstract Seq<T>`	`padTo(int len, T elem)` Appends an element value to this sequence until a given target length is reached.
`abstract ParSeq<T>`	`par()` Returns a parallel implementation of this collection.
`abstract Tuple2<Seq<T>,Seq<T>>`	`partition(Function1<T,Boolean> p)` Partitions this sequence in two sequences according to a predicate.
`abstract Seq<T>`	`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.
`abstract <U> U`	`reduceLeft(Function2<U,T,U> op)` Applies a binary operator to all elements of this immutable sequence, going left to right.
`abstract <U> Option<U>`	`reduceLeftOption(Function2<U,T,U> op)` Optionally applies a binary operator to all elements of this immutable sequence, going left to right.
`abstract <U> U`	`reduceRight(Function2<T,U,U> op)` Applies a binary operator to all elements of this immutable sequence, going right to left.
`abstract <U> Option<U>`	`reduceRightOption(Function2<T,U,U> op)` Optionally applies a binary operator to all elements of this immutable sequence, going right to left.
`abstract Seq<T>`	`reverse()` Returns new sequence wih elements in reversed order.
`abstract <U> Seq<U>`	`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.
`abstract boolean`	`sameElements(Seq<T> that)` Checks if the other iterable collection contains the same elements in the same order as this sequence.
`abstract <U> Function1<Function2<U,T,U>,Seq<U>>`	`scanLeft(U z)` Curried `scanLeft(Object, Function2)`
`abstract <U> Seq<U>`	`scanLeft(U z, Function2<U,T,U> op)` Produces a collection containing cummulative results of applying the operator going left to right.
`abstract <U> Function1<Function2<T,U,U>,Seq<U>>`	`scanRight(U z)` Curried `scanRight(Object, Function2)`
`abstract <U> Seq<U>`	`scanRight(U z, Function2<T,U,U> op)` Produces a collection containing cummulative results of applying the operator going right to left.
`abstract int`	`size()` The size of this sequence, equivalent to length.
`abstract Seq<T>`	`slice(int from, int until)` Selects an interval of elements.
`abstract Seq<Seq<T>>`	`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.
`abstract Seq<Seq<T>>`	`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.
`abstract Seq<T>`	`sortWith(Function2<T,T,Boolean> lt)` Sorts this sequence according to a comparison function.
`abstract Tuple2<Seq<T>,Seq<T>>`	`span(Function1<T,Boolean> p)` Splits this sequence into a prefix/suffix pair according to a predicate.
`abstract Tuple2<Seq<T>,Seq<T>>`	`splitAt(int n)` Splits this sequence into two at a given position.
`abstract boolean`	`startsWith(Seq<T> that)` Tests whether this sequence contains the given sequence at a given index.
`abstract boolean`	`startsWith(Seq<T> that, int offset)` Tests whether this sequence contains the given sequence at a given index.
`abstract SNum`	`sum()` Sums up the elements of this collection.
`abstract Seq<T>`	`tail()` Selects all elements except the first.
`abstract Seq<T>`	`take(int n)` Selects first n elements.
`abstract Seq<T>`	`takeRight(int n)` Selects last n elements.
`abstract Seq<T>`	`takeWhile(Function1<T,Boolean> p)` Takes longest prefix of elements that satisfy a predicate.
`abstract Seq<T>`	`transpose()` Transposes this list of traversable collections into a list of lists.
`abstract Seq<T>`	`union(Seq<T> that)` Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence.
`abstract Seq<T>`	`updated(int index, T elem)` A copy of this sequence with one single replaced element.
`abstract <U> Seq<Tuple2<T,U>>`	`zip(Seq<U> that)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`abstract Seq<Tuple2<T,Integer>>`	`zipWithIndex()` Zips this sequence with its indices.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.m3.scalaflavor4j.CollectionLike
foreach, isEmpty, toList

- Constructor Detail
 - Seq
```
public Seq()
```
- Method Detail
 - apply
```
public static <T> Seq<T> apply(T... values)
```
 - apply
```
public static <T> Seq<T> apply(Enumeration<T> e)
```
 - apply
```
public static <T> Seq<T> apply(Iterator<T> iter)
```
 - apply
```
public static <T> Seq<T> apply(Iterable<T> iterable)
```
 - applyCollection
```
protected static <T> Seq<T> applyCollection(Collection<T> col)
```
 - append
```
public abstract Seq<T> append(T... that)
```
 [Original] Appends the passed elements This method is similar to scala.collectoin.Seq#+:(A)
 - contains
```
public abstract boolean contains(T elem)
```
 Tests whether this sequence contains a given value as an element.
 - corresponds
```
public abstract  boolean corresponds(Seq 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.
 - corresponds
```
public abstract  Function1<Function2<T,U,Boolean>,Boolean> corresponds(Seq that)
```
 Curried corresponds(Seq)
 - count
```
public abstract int count(Function1<T,Boolean> p)
```
 Counts the number of elements in the sequence which satisfy a predicate.
 - diff
```
public abstract Seq<T> diff(Seq<T> that)
```
 Computes the multiset difference between this sequence and another sequence.
 - distinct
```
public abstract Seq<T> distinct()
```
 Builds a new sequence from this sequence without any duplicate elements.
 - drop
```
public abstract Seq<T> drop(int n)
```
 Selects all elements except first n ones.
 - dropNull
```
public abstract Seq<T> dropNull()
```
 [Original] Drops null elements
 - dropRight
```
public abstract Seq<T> dropRight(int n)
```
 Selects all elements except last n ones.
 - dropWhile
```
public abstract Seq<T> dropWhile(Function1<T,Boolean> p)
```
 Drops longest prefix of elements that satisfy a predicate.
 - endsWith
```
public abstract boolean endsWith(Seq<T> that)
```
 Tests whether this sequence ends with the given sequence.
 - exists
```
public abstract boolean exists(Function1<T,Boolean> p)
```
 Tests whether a predicate holds for some of the elements of this sequence.
 - filter
```
public abstract Seq<T> filter(Function1<T,Boolean> f)
```
 Selects all elements of this sequence which satisfy a predicate.
 - filterNot
```
public abstract Seq<T> filterNot(Function1<T,Boolean> f)
```
 Selects all elements of this immutable sequence which do not satisfy a predicate.
 - find
```
public abstract Option<T> find(Function1<T,Boolean> p)
```
 Finds the first element of the sequence satisfying a predicate, if any.
 - flatMap
```
public abstract  Seq flatMap(Function1<T,CollectionLike> f)
```
 Builds a new collection by applying a function to all elements of this sequence and concatenating the results.
 - foldLeft
```
public abstract  U foldLeft(U z,
 Function2<U,T,U> op)
```
 Applies a binary operator to a start value and all elements of this sequence, going left to right.
 - foldLeft
```
public abstract  Function1<Function2<U,T,U>,U> foldLeft(U z)
```
 Curried foldLeft(Object, Function2)
 - foldRight
```
public abstract  U foldRight(U z,
 Function2<T,U,U> op)
```
 Applies a binary operator to all elements of this sequence and a start value, going right to left.
 - foldRight
```
public abstract  Function1<Function2<T,U,U>,U> foldRight(U z)
```
 Curried foldRight(Object, Function2)
 - forall
```
public abstract boolean forall(Function1<T,Boolean> p)
```
 Tests whether a predicate holds for all elements of this sequence.
 - groupBy
```
public abstract  SMap<U,Seq<T>> groupBy(Function1<T,U> f)
```
 Partitions this sequence into a map of sequences according to some discriminator function.
 - head
```
public abstract T head()
```
 Selects the first element of this sequence.
 - headOption
```
public abstract Option<T> headOption()
```
 Optionally selects the first element.
 - indexOf
```
public abstract int indexOf(T elem)
```
 Finds index of first occurrence of some value in this sequence after or at some start index.
 - indices
```
public abstract Seq<Integer> indices()
```
 Produces the range of all indices of this sequence.
 - init
```
public abstract Seq<T> init()
```
 Selects all elements except the last.
 - intersect
```
public abstract Seq<T> intersect(Seq<T> that)
```
 Computes the multiset intersection between this sequence and another sequence.
 - isDefinedAt
```
public abstract boolean isDefinedAt(int idx)
```
 Tests whether this sequence contains given index.
 - last
```
public abstract T last()
```
 Selects the last element.
 - lastOption
```
public abstract Option<T> lastOption()
```
 Optionally selects the last element.
 - map
```
public abstract  Seq map(Function1<T,U> f)
```
 Builds a new collection by applying a function to all elements of this sequence.
 - max
```
public abstract SNum max()
```
 Finds the largest element.
 - min
```
public abstract SNum min()
```
 Finds the smallest element.
 - mkString
```
public abstract String mkString()
```
 Displays all elements of this sequence in a string.
 - mkString
```
public abstract String mkString(String sep)
```
 Displays all elements of this sequence in a string using a separator string.
 - mkString
```
public abstract String mkString(String start,
 String sep,
 String end)
```
 Displays all elements of this sequence in a string using start, end, and separator strings.
 - padTo
```
public abstract Seq<T> padTo(int len,
 T elem)
```
 Appends an element value to this sequence until a given target length is reached.
 - par
```
public abstract ParSeq<T> par()
```
 Returns a parallel implementation of this collection.
 - partition
```
public abstract Tuple2<Seq<T>,Seq<T>> partition(Function1<T,Boolean> p)
```
 Partitions this sequence in two sequences according to a predicate.
 - patch
```
public abstract Seq<T> 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.
 - reduceLeft
```
public abstract  U reduceLeft(Function2<U,T,U> op)
```
 Applies a binary operator to all elements of this immutable sequence, going left to right.
 - reduceLeftOption
```
public abstract  Option reduceLeftOption(Function2<U,T,U> op)
```
 Optionally applies a binary operator to all elements of this immutable sequence, going left to right.
 - reduceRight
```
public abstract  U reduceRight(Function2<T,U,U> op)
```
 Applies a binary operator to all elements of this immutable sequence, going right to left.
 - reduceRightOption
```
public abstract  Option reduceRightOption(Function2<T,U,U> op)
```
 Optionally applies a binary operator to all elements of this immutable sequence, going right to left.
 - reverse
```
public abstract Seq<T> reverse()
```
 Returns new sequence wih elements in reversed order.
 - reverseMap
```
public abstract  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.
 - sameElements
```
public abstract boolean sameElements(Seq<T> that)
```
 Checks if the other iterable collection contains the same elements in the same order as this sequence.
 - scanLeft
```
public abstract  Seq scanLeft(U z,
 Function2<U,T,U> op)
```
 Produces a collection containing cummulative results of applying the operator going left to right.
 - scanLeft
```
public abstract  Function1<Function2<U,T,U>,Seq> scanLeft(U z)
```
 Curried scanLeft(Object, Function2)
 - scanRight
```
public abstract  Seq scanRight(U z,
 Function2<T,U,U> op)
```
 Produces a collection containing cummulative results of applying the operator going right to left.
 - scanRight
```
public abstract  Function1<Function2<T,U,U>,Seq> scanRight(U z)
```
 Curried scanRight(Object, Function2)
 - size
```
public abstract int size()
```
 The size of this sequence, equivalent to length.
 - slice
```
public abstract Seq<T> slice(int from,
 int until)
```
 Selects an interval of elements.
 - sliding
```
public abstract Seq<Seq<T>> 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.
 - sliding
```
public abstract Seq<Seq<T>> 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.
 - sortWith
```
public abstract Seq<T> sortWith(Function2<T,T,Boolean> lt)
```
 Sorts this sequence according to a comparison function.
 - span
```
public abstract Tuple2<Seq<T>,Seq<T>> span(Function1<T,Boolean> p)
```
 Splits this sequence into a prefix/suffix pair according to a predicate.
 - splitAt
```
public abstract Tuple2<Seq<T>,Seq<T>> splitAt(int n)
```
 Splits this sequence into two at a given position.
 - startsWith
```
public abstract boolean startsWith(Seq<T> that)
```
 Tests whether this sequence contains the given sequence at a given index.
 - startsWith
```
public abstract boolean startsWith(Seq<T> that,
 int offset)
```
 Tests whether this sequence contains the given sequence at a given index.
 - sum
```
public abstract SNum sum()
```
 Sums up the elements of this collection.
 - tail
```
public abstract Seq<T> tail()
```
 Selects all elements except the first.
 - take
```
public abstract Seq<T> take(int n)
```
 Selects first n elements.
 - takeRight
```
public abstract Seq<T> takeRight(int n)
```
 Selects last n elements.
 - takeWhile
```
public abstract Seq<T> takeWhile(Function1<T,Boolean> p)
```
 Takes longest prefix of elements that satisfy a predicate.
 - transpose
```
public abstract Seq<T> transpose()
```
 Transposes this list of traversable collections into a list of lists.
 - union
```
public abstract Seq<T> union(Seq<T> that)
```
 Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence.
 - updated
```
public abstract Seq<T> updated(int index,
 T elem)
```
 A copy of this sequence with one single replaced element.
 - zip
```
public abstract  Seq<Tuple2<T,U>> zip(Seq that)
```
 Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
 - zipWithIndex
```
public abstract Seq<Tuple2<T,Integer>> zipWithIndex()
```
 Zips this sequence with its indices.

Class Seq<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.m3.scalaflavor4j.CollectionLike

Constructor Detail

Seq

Method Detail

apply

apply

apply

apply

applyCollection

append

contains

corresponds

corresponds

count

diff

distinct

drop

dropNull

dropRight

dropWhile

endsWith

exists

filter

filterNot

find

flatMap

foldLeft

foldLeft

foldRight

foldRight

forall

groupBy

head

headOption

indexOf

indices

init

intersect

isDefinedAt

last

lastOption

map

max

min

mkString

mkString

mkString

padTo

par

partition

patch

reduceLeft

reduceLeftOption

reduceRight

reduceRightOption

reverse

reverseMap

sameElements

scanLeft

scanLeft

scanRight

scanRight

size

slice

sliding

sliding

sortWith

span

splitAt

startsWith

startsWith

sum

tail

take

takeRight

takeWhile