SequenceBase (Java Tool 1.2.2 API)

java.lang.Object
- org.osgl.util.FeaturedBase
- - org.osgl.util.TraversableBase<T>
  - - org.osgl.util.SequenceBase<T>

All Implemented Interfaces:

Iterable<T>, C.Featured, C.Sequence<T>, C.Traversable<T>

Direct Known Subclasses:

C.Array, LazyRange
```
public abstract class SequenceBase<T>
extends TraversableBase<T>
implements C.Sequence<T>
```
Provide default implementation to some C.Sequence interface.
The most of the method of this implementation is lazy without regarding to the C.Feature.LAZY setting of this sequence instance

Nested Class Summary
- Nested classes/interfaces inherited from interface org.osgl.util.C.Featured
  C.Featured.Factory

Constructor Summary

Constructors
Constructor and Description

SequenceBase()

Constructors
Constructor and Description
`SequenceBase()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SequenceBase<T>`	`accept(Osgl.Function<? super T,?> visitor)` Iterate this `Traversable` with a visitor function.
`C.Sequence<T>`	`acceptLeft(Osgl.Function<? super T,?> visitor)` Iterate through this sequence from head to tail with the visitor function specified
`C.Sequence<T>`	`append(C.Sequence<? extends T> seq)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified sequence.
`C.Sequence<T>`	`append(Enumeration<? extends T> enumeration)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified enumeration.
`C.Sequence<T>`	`append(Iterable<? extends T> iterable)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterable.
`C.Sequence<T>`	`append(Iterator<? extends T> iterator)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterator.
`C.Sequence<T>`	`append(T t)` Returns a sequence consists of all elements of this sequence followed by the element specified.
`static <T> int`	`count(C.Sequence<T> sequence, T element)`
`int`	`count(T t)` Count the element occurence in this sequence
`C.Sequence<T>`	`drop(int n)` Returns a `Sequence` consisting of the elements from this `Sequence` except the first `n` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.Sequence<T>`	`dropWhile(Osgl.Function<? super T,Boolean> predicate)` Returns a `Sequence` consisting of the elements from this sequence with leading elements dropped until the predicate returns `true`
`C.Sequence<T>`	`each(Osgl.Function<? super T,?> visitor)` Alias of `C.Traversable.accept(Osgl.Function)`
`C.Sequence<T>`	`eager()` Returns this traversable and turn off `C.Feature.LAZY`
`C.Sequence<T>`	`filter(Osgl.Function<? super T,Boolean> predicate)` Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
`Osgl.Option<T>`	`findFirst(Osgl.Function<? super T,Boolean> predicate)` Delegate to `TraversableBase.findOne(org.osgl.Osgl.Function)`
`T`	`first()` Alias of `C.Sequence.head()`
`<R> C.Sequence<R>`	`flatMap(Osgl.Function<? super T,? extends Iterable<? extends R>> mapper)` Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element.
`SequenceBase<T>`	`forEach(Osgl.Function<? super T,?> visitor)` Iterate through this traversal and apply the visitor function specified to each element iterated
`protected void`	`forEachLeft(Osgl.Function<? super T,?> visitor)`
`T`	`head()` Returns an `$.Option` of the first element in the `Sequence` or `Osgl.NONE` if the `Sequence` is empty
`C.Sequence<T>`	`head(int n)` Alias of `C.Sequence.take(int)`
`protected EnumSet<C.Feature>`	`initFeatures()` Sub class should override this method to provide initial feature set for the feature based instance
`protected boolean`	`isImmutable()`
`protected boolean`	`isLazy()`
`protected boolean`	`isLimited()`
`protected boolean`	`isMutable()`
`protected boolean`	`isReadOnly()`
`C.Sequence<T>`	`lazy()` Returns this traversable and try to turn on `C.Feature.LAZY`.
`<R> C.Sequence<R>`	`map(Osgl.Function<? super T,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`C.Sequence<T>`	`parallel()` Returns this traversable and try to turn on `C.Feature.PARALLEL`.
`C.Sequence<T>`	`prepend(C.Sequence<? extends T> seq)` Returns a sequence consists of all elements of the sequence specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(Enumeration<? extends T> enumeration)` Returns a sequence consists of all elements of the enumeration specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(Iterable<? extends T> iterable)` Returns a sequence consists of all elements of the iterable specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(Iterator<? extends T> iterator)` Returns a sequence consists of all elements of the iterator specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(T t)` Returns a sequence consists of the element specified followed by all elements of this sequence.
`Osgl.Option<T>`	`reduceLeft(Osgl.Func2<T,T,T> accumulator)` Delegate to `TraversableBase.reduce(org.osgl.Osgl.Func2)`
`<R> R`	`reduceLeft(R identity, Osgl.Func2<R,T,R> accumulator)` Delegate to `TraversableBase.reduce(Object, org.osgl.Osgl.Func2)`
`C.Sequence<T>`	`sequential()` Returns this traversable and turn off `C.Feature.PARALLEL`
`C.Sequence<T>`	`tail()` Returns the rest part of the `Sequence` except the first element
`C.Sequence<T>`	`take(int n)` Returns a `Sequence` consisting the first `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.Sequence<T>`	`takeWhile(Osgl.Function<? super T,Boolean> predicate)` Returns an new `Sequence` that takes the head of this `Sequence` until the predicate evaluate to `false`:
`<T2> C.Sequence<Osgl.T2<T,T2>>`	`zip(Iterable<T2> iterable)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<T2> C.Sequence<Osgl.T2<T,T2>>`	`zipAll(Iterable<T2> iterable, T def1, T2 def2)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`C.Sequence<Osgl.T2<T,Integer>>`	`zipWithIndex()` Zip this sequence with its indices

Methods inherited from class org.osgl.util.TraversableBase
allMatch, anyMatch, findOne, generateHashCode, hashCode, isEmpty, noneMatch, reduce, reduce

Methods inherited from class org.osgl.util.FeaturedBase
features_, features, is, setFeature, unsetFeature

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

Methods inherited from interface org.osgl.util.C.Sequence
reduce, reduce

Methods inherited from interface org.osgl.util.C.Traversable
allMatch, anyMatch, findOne, isEmpty, noneMatch, size

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

Methods inherited from interface org.osgl.util.C.Featured
features, is

- Constructor Detail
  - SequenceBase
```
public SequenceBase()
```
- Method Detail
  - isLazy
```
protected final boolean isLazy()
```
  - isImmutable
```
protected final boolean isImmutable()
```
  - isReadOnly
```
protected final boolean isReadOnly()
```
  - isMutable
```
protected final boolean isMutable()
```
  - isLimited
```
protected final boolean isLimited()
```
  - lazy
```
public C.Sequence<T> lazy()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and try to turn on C.Feature.LAZY. If lazy is not supported then return this traversable directly without any state change
    
    Specified by:
    
    lazy in interface C.Sequence<T>
    
    Specified by:
    
    lazy in interface C.Traversable<T>
    
    Overrides:
    
    lazy in class TraversableBase<T>
    
    Returns:
    
    this reference with lazy turned on if it is supported
  - eager
```
public C.Sequence<T> eager()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and turn off C.Feature.LAZY
    
    Specified by:
    
    eager in interface C.Sequence<T>
    
    Specified by:
    
    eager in interface C.Traversable<T>
    
    Overrides:
    
    eager in class TraversableBase<T>
    
    Returns:
    
    this reference with lazy turned off
  - parallel
```
public C.Sequence<T> parallel()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and try to turn on C.Feature.PARALLEL. If this traversable does not support C.Feature.PARALLEL then return this traversable directly without any state change
    
    Specified by:
    
    parallel in interface C.Sequence<T>
    
    Specified by:
    
    parallel in interface C.Traversable<T>
    
    Overrides:
    
    parallel in class TraversableBase<T>
    
    Returns:
    
    this reference with parallel turned on if parallel is supported
  - sequential
```
public C.Sequence<T> sequential()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and turn off C.Feature.PARALLEL
    
    Specified by:
    
    sequential in interface C.Sequence<T>
    
    Specified by:
    
    sequential in interface C.Traversable<T>
    
    Overrides:
    
    sequential in class TraversableBase<T>
    
    Returns:
    
    this reference with parallel turned off
  - initFeatures
```
protected EnumSet<C.Feature> initFeatures()
```
    Description copied from class: FeaturedBase
    
    Sub class should override this method to provide initial feature set for the feature based instance
    
    Overrides:
    
    initFeatures in class TraversableBase<T>
    
    Returns:
    
    the initial feature set configuration
  - accept
```
public SequenceBase<T> accept(Osgl.Function<? super T,?> visitor)
```
    Description copied from interface: C.Traversable
    
    Iterate this Traversable with a visitor function. This method does not specify the approach to iterate through this structure. The implementation might choose iterate from left to right, or vice versa. It might even choose to split the structure into multiple parts, and iterate through them in parallel
    
    Specified by:
    
    accept in interface C.Sequence<T>
    
    Specified by:
    
    accept in interface C.Traversable<T>
    
    Overrides:
    
    accept in class TraversableBase<T>
    
    Parameters:
    
    visitor - a function that apply to element in this Traversable. The return value of the function is ignored
    
    Returns:
    
    this Traversable instance for chained call
  - forEach
```
public SequenceBase<T> forEach(Osgl.Function<? super T,?> visitor)
```
    Description copied from class: TraversableBase
    
    Iterate through this traversal and apply the visitor function specified to each element iterated
    
    Specified by:
    
    forEach in interface C.Sequence<T>
    
    Specified by:
    
    forEach in interface C.Traversable<T>
    
    Overrides:
    
    forEach in class TraversableBase<T>
    
    Parameters:
    
    visitor - the visitor function
    
    Returns:
    
    this Traversable instance
  - each
```
public C.Sequence<T> each(Osgl.Function<? super T,?> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Osgl.Function)
    
    Specified by:
    
    each in interface C.Sequence<T>
    
    Specified by:
    
    each in interface C.Traversable<T>
    
    Overrides:
    
    each in class TraversableBase<T>
    
    Parameters:
    
    visitor - the visitor to tranverse the elements
    
    Returns:
    
    this Traversable instance
  - forEachLeft
```
protected void forEachLeft(Osgl.Function<? super T,?> visitor)
```
  - first
```
public T first()
        throws NoSuchElementException
```
    Description copied from interface: C.Sequence
    
    Alias of C.Sequence.head()
    
    Specified by:
    
    first in interface C.Sequence<T>
    
    Returns:
    
    the first element in the sequence
    
    Throws:
    
    NoSuchElementException
  - head
```
public final T head()
             throws NoSuchElementException
```
    Description copied from interface: C.Sequence
    
    Returns an $.Option of the first element in the Sequence or Osgl.NONE if the Sequence is empty
    
    Specified by:
    
    head in interface C.Sequence<T>
    
    Returns:
    
    the first element from the Sequence
    
    Throws:
    
    NoSuchElementException - if the Sequence is empty
    
    See Also:
    
    C.Sequence.tail(), C.Sequence.first()
  - acceptLeft
```
public C.Sequence<T> acceptLeft(Osgl.Function<? super T,?> visitor)
```
    Description copied from interface: C.Sequence
    
    Iterate through this sequence from head to tail with the visitor function specified
    
    Specified by:
    
    acceptLeft in interface C.Sequence<T>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Osgl.Function), C.ReversibleSequence.acceptRight(Osgl.Function)
  - reduceLeft
```
public <R> R reduceLeft(R identity,
                        Osgl.Func2<R,T,R> accumulator)
```
    Delegate to TraversableBase.reduce(Object, org.osgl.Osgl.Func2)
    
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Type Parameters:
    
    R - the aggregation result type
    
    Parameters:
    
    identity - the identity value for the accumulating function
    
    accumulator - the function to accumulate two values
    
    Returns:
    
    the reduced result
  - reduceLeft
```
public Osgl.Option<T> reduceLeft(Osgl.Func2<T,T,T> accumulator)
```
    Delegate to TraversableBase.reduce(org.osgl.Osgl.Func2)
    
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Parameters:
    
    accumulator - the function accumulate each element to the final result
    
    Returns:
    
    an $.Option describing the accumulating result
  - findFirst
```
public Osgl.Option<T> findFirst(Osgl.Function<? super T,Boolean> predicate)
```
    Delegate to TraversableBase.findOne(org.osgl.Osgl.Function)
    
    Specified by:
    
    findFirst in interface C.Sequence<T>
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Osgl.none()
  - head
```
public C.Sequence<T> head(int n)
```
    Description copied from interface: C.Sequence
    
    Alias of C.Sequence.take(int)
    
    Specified by:
    
    head in interface C.Sequence<T>
    
    Parameters:
    
    n - the number of elements to be taken into the return sequence
    
    Returns:
    
    the first n element in the sequence
  - tail
```
public C.Sequence<T> tail()
                   throws UnsupportedOperationException
```
    Description copied from interface: C.Sequence
    
    Returns the rest part of the Sequence except the first element
    
    Specified by:
    
    tail in interface C.Sequence<T>
    
    Returns:
    
    a Sequence without the first element
    
    Throws:
    
    UnsupportedOperationException - if the Sequence is empty
    
    See Also:
    
    C.Sequence.head(), C.ReversibleSequence.tail(int)
  - take
```
public C.Sequence<T> take(int n)
```
    Description copied from interface: C.Sequence
    Returns a Sequence consisting the first n elements from this Sequence if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.
    
    If the number n is zero, then an empty Sequence is returned in reverse order
    
    If the number n is negative, then the last -n elements from this Sequence is returned in an new Sequence, or throw UnsupportedOperationException if this operation is not supported
```
     Sequence seq = C.list(1, 2, 3, 4);
     assertEquals(C.list(1, 2), seq.take(2));
     assertEquals(C.list(1, 2, 3, 4), seq.take(100));
     assertEquals(C.list(), seq.take(0));
     assertEquals(C.list(3, 4), seq.take(-2));
     assertEquals(C.list(1, 2, 3, 4), seq.take(-200));
 
```
    Specified by:
    
    take in interface C.Sequence<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence
    
    Returns:
    
    a Sequence consisting of the first n elements of this Sequence
    
    See Also:
    
    C.Sequence.head(int)
  - takeWhile
```
public C.Sequence<T> takeWhile(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    Returns an new Sequence that takes the head of this Sequence until the predicate evaluate to false:
```
     C.Sequence seq = C.list(1, 2, 3, 4, 5, 4, 3, 2, 1);
     assertEquals(C.list(C.list(1, 2, 3), seq.takeWhile(_.F.lt(4)));
     assertEquals(C.list(C.list(1, 2, 3, 3, 2, 1), seq.filter(_.F.lt(4)));
 
```
    Specified by:
    
    takeWhile in interface C.Sequence<T>
    
    Parameters:
    
    predicate - specify which the elements in this Sequence will put into the new Sequence
    
    Returns:
    
    the new Sequence
  - drop
```
public C.Sequence<T> drop(int n)
                   throws IllegalArgumentException
```
    Description copied from interface: C.Sequence
    Returns a Sequence consisting of the elements from this Sequence except the first n if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then an empty Sequence is returned
    
    If the number n is zero, then a copy of this Sequence or this Sequence itself is returned depending on the implementation
    
    If the number n is negative, then either IllegalArgumentException should be thrown out if this sequence is not C.Feature.LIMITED or it drop -n element starts from the tail side
```
     C.Sequence seq = C.list(1, 2, 3, 4, 5);
     assertEquals(C.list(3, 4, 5), seq.drop(2));
     assertEquals(C.list(1, 2, 3, 4, 5), seq.drop(0));
     assertEquals(C.list(), seq.drop(100));
 
```
    Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required
    Specified by:
    
    drop in interface C.Sequence<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence must not less than 0
    
    Returns:
    
    a Sequence consisting of the elements of this Sequence except the first n ones
    
    Throws:
    
    IllegalArgumentException
  - dropWhile
```
public C.Sequence<T> dropWhile(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    Returns a Sequence consisting of the elements from this sequence with leading elements dropped until the predicate returns true
```
      Sequence seq = C.list(1, 2, 3, 4, 3, 2, 1);
      assertTrue(C.list(), seq.dropWhile(_.F.gt(100)));
      assertTrue(C.list(4, 3, 2, 1), seq.dropWhile(_.F.lt(3)));
 
```
    Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required
    Specified by:
    
    dropWhile in interface C.Sequence<T>
    
    Parameters:
    
    predicate - the function that check if drop operation should stop
    
    Returns:
    
    the sequence after applying the drop operations
  - append
```
public C.Sequence<T> append(Iterable<? extends T> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterable.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    iterable - the iterable in which elements will be append to this sequence
    
    Returns:
    
    the sequence after append the iterable
  - append
```
public C.Sequence<T> append(C.Sequence<? extends T> seq)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified sequence.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    seq - the sequence to be appended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - append
```
public C.Sequence<T> append(Iterator<? extends T> iterator)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterator.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    iterator - the iterator in which elements will be append to the returned sequence
    
    Returns:
    
    a sequence consists of elements of this sequence and the elements in the iterator
  - append
```
public C.Sequence<T> append(Enumeration<? extends T> enumeration)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified enumeration.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    enumeration - the enumeration in which elements will be append to the returned sequence
    
    Returns:
    
    a sequence consists of elements of this sequence and the elements in the iterator
  - append
```
public C.Sequence<T> append(T t)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by the element specified.
    an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    t - the element to be appended to this sequence
    
    Returns:
    
    a sequence consists of elements of this sequence and the element t
  - prepend
```
public C.Sequence<T> prepend(Iterable<? extends T> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the iterable specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    iterable - the iterable to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(Iterator<? extends T> iterator)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the iterator specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    iterator - the iterator to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(Enumeration<? extends T> enumeration)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the enumeration specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    enumeration - the enumeration to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(C.Sequence<? extends T> seq)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the sequence specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    seq - the sequence to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(T t)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of the element specified followed by all elements of this sequence.
    an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    t - the element to be appended to this sequence
    
    Returns:
    
    the sequence consists of t followed by all elements in this sequence
  - filter
```
public C.Sequence<T> filter(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
```
     Traversable traversable = C.list(-1, 0, 1, -3, 7);
     Traversable filtered = traversable.filter(_.F.gt(0));
     assertTrue(filtered.contains(1));
     assertFalse(filtered.contains(-3));
 
```
    Specified by:
    
    filter in interface C.Sequence<T>
    
    Specified by:
    
    filter in interface C.Traversable<T>
    
    Overrides:
    
    filter in class TraversableBase<T>
    
    Parameters:
    
    predicate - the function that test if the element in the traversable should be kept in the resulting traversable. When applying the filter function to the element, if the result is true then the element will be kept in the resulting traversable.
    
    Returns:
    
    the new traversable consists of elements passed the filter function test
  - map
```
public <R> C.Sequence<R> map(Osgl.Function<? super T,? extends R> mapper)
```
    Description copied from interface: C.Traversable
    Returns an new traversable with a mapper function specified. The element in the new traversal is the result of the mapper function applied to this traversal element.
```
     Traversable traversable = C.list(23, _.NONE, null);
     assertEquals(C.list(true, false, false), traversal.map(_.F.NOT_NULL));
     assertEquals(C.list("23", "", ""), traversal.map(_.F.AS_STRING));
 
```
    For Lazy Traversable, it must use lazy evaluation for this method. Otherwise it is up to implementation to decide whether use lazy evaluation or not
    Specified by:
    
    map in interface C.Sequence<T>
    
    Specified by:
    
    map in interface C.Traversable<T>
    
    Overrides:
    
    map in class TraversableBase<T>
    
    Type Parameters:
    
    R - the element type of the new traversal
    
    Parameters:
    
    mapper - the function that applied to element in this traversal and returns element in the result traversal
    
    Returns:
    
    the new traversal contains results of the mapper function applied to this traversal
  - flatMap
```
public <R> C.Sequence<R> flatMap(Osgl.Function<? super T,? extends Iterable<? extends R>> mapper)
```
    Description copied from interface: C.Traversable
    
    Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element. If the result of the mapping function is null, this is treated as if the result is an empty traversable.
    
    Specified by:
    
    flatMap in interface C.Sequence<T>
    
    Specified by:
    
    flatMap in interface C.Traversable<T>
    
    Overrides:
    
    flatMap in class TraversableBase<T>
    
    Type Parameters:
    
    R - the element type of the the new traversable
    
    Parameters:
    
    mapper - the function produce an iterable when applied to an element
    
    Returns:
    
    the new traversable
  - zip
```
public <T2> C.Sequence<Osgl.T2<T,T2>> zip(Iterable<T2> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface C.Sequence<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    iterable - the part B to be zipped with this sequence
    
    Returns:
    
    a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the minimum of the lengths of this sequence and that.
  - zipAll
```
public <T2> C.Sequence<Osgl.T2<T,T2>> zipAll(Iterable<T2> iterable,
                                             T def1,
                                             T2 def2)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
    
    Specified by:
    
    zipAll in interface C.Sequence<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    iterable - the part B to be zipped with this sequence
    
    def1 - the element to be used to fill up the result if this sequence is shorter than that iterable
    
    def2 - the element to be used to fill up the result if the iterable is shorter than this sequence
    
    Returns:
    
    a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the maximum of the lengths of this sequence and that.
  - zipWithIndex
```
public C.Sequence<Osgl.T2<T,Integer>> zipWithIndex()
```
    Description copied from interface: C.Sequence
    
    Zip this sequence with its indices
    
    Specified by:
    
    zipWithIndex in interface C.Sequence<T>
    
    Returns:
    
    A new list containing pairs consisting of all elements of this list paired with their index. Indices start at 0.
  - count
```
public int count(T t)
```
    Description copied from interface: C.Sequence
    
    Count the element occurence in this sequence
    
    Specified by:
    
    count in interface C.Sequence<T>
    
    Parameters:
    
    t - the element
    
    Returns:
    
    the number of times the element be presented in this sequence
  - count
```
public static <T> int count(C.Sequence<T> sequence,
                            T element)
```

Class SequenceBase<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.osgl.util.C.Featured

Constructor Summary

Method Summary

Methods inherited from class org.osgl.util.TraversableBase

Methods inherited from class org.osgl.util.FeaturedBase

Methods inherited from class java.lang.Object

Methods inherited from interface org.osgl.util.C.Sequence

Methods inherited from interface org.osgl.util.C.Traversable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.osgl.util.C.Featured

Constructor Detail

SequenceBase

Method Detail

isLazy

isImmutable

isReadOnly

isMutable

isLimited

lazy

eager

parallel

sequential

initFeatures

accept

forEach

each

forEachLeft

first

head

acceptLeft

reduceLeft

reduceLeft

findFirst

head

tail

take

takeWhile

drop

dropWhile

append

append

append

append

append

prepend

prepend

prepend

prepend

prepend

filter

map

flatMap

zip

zipAll

zipWithIndex

count

count