Osgl.Var (Java Tool 1.2.2 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<T>
  - - org.osgl.util.ListBase<T>
    - - org.osgl.Osgl.Var<T>

All Implemented Interfaces:

Iterable<T>, Collection<T>, List<T>, Set<T>, Osgl.Func0<T>, C.Featured, C.List<T>, C.ListOrSet<T>, C.ReversibleSequence<T>, C.Sequence<T>, C.Set<T>, C.Traversable<T>

Direct Known Subclasses:

Osgl.Val

Enclosing class:

Osgl
```
public static class Osgl.Var<T>
extends ListBase<T>
implements C.ListOrSet<T>, Osgl.Func0<T>
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class Osgl.Var._f
- Nested classes/interfaces inherited from interface org.osgl.util.C.List
  C.List.Cursor<T>
- Nested classes/interfaces inherited from interface org.osgl.util.C.Featured
  C.Featured.Factory

Nested Classes
Modifier and Type	Class and Description
`class`	`Osgl.Var._f`

Field Summary

Fields
Modifier and Type Field and Description

Osgl.Var._f f
- Fields inherited from class java.util.AbstractList
  modCount

Fields
Modifier and Type	Field and Description
`Osgl.Var._f`	`f`

Constructor Summary

Constructors
Constructor and Description

Var(T value)

Constructors
Constructor and Description
`Var(T value)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Osgl.Var<T>`	`accept(Osgl.Function<? super T,?> visitor)` Iterate this `Traversable` with a visitor function.
`Osgl.Var<T>`	`acceptLeft(Osgl.Function<? super T,?> visitor)` Iterate through this sequence from head to tail with the visitor function specified
`C.List<T>`	`acceptRight(Osgl.Func2<Integer,? super T,?> indexedVisitor)` Loop through the list from `size() - 1` to `0`.
`C.List<T>`	`acceptRight(Osgl.Function<? super T,?> visitor)` Iterate through this sequence from tail to head with the visitor function specified
`void`	`add(int index, T element)`
`boolean`	`add(T t)`
`boolean`	`addAll(Collection<? extends T> c)`
`boolean`	`addAll(int index, Collection<? extends T> c)`
`boolean`	`addAll(Iterable<? extends T> iterable)` Add all elements from an `Iterable` into this list.
`boolean`	`allMatch(Osgl.Function<? super T,Boolean> predicate)` Check if all elements match the predicate specified
`boolean`	`anyMatch(Osgl.Function<? super T,Boolean> predicate)` Check if any elements matches the predicate specified
`T`	`apply()` user application to implement main logic of applying the function
`void`	`clear()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`C.List<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.List<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`
`Osgl.Var<T>`	`each(Osgl.Function<? super T,?> visitor)` Alias of `C.Traversable.accept(Osgl.Function)`
`Osgl.Var<T>`	`eager()` Returns this traversable and make sure `C.Feature.LAZY` is unset
`boolean`	`equals(Object o)`
`C.ListOrSet<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)` Apply the predicate specified to the element of this sequence from head to tail.
`Osgl.Option<T>`	`findLast(Osgl.Function<? super T,Boolean> predicate)` Apply the predicate specified to the element of this sequence from tail to head.
`Osgl.Option<T>`	`findOne(Osgl.Function<? super T,Boolean> predicate)` Returns an element that matches the predicate specified.
`<R> C.List<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.
`Osgl.Var<T>`	`forEach(Osgl.Function<? super T,?> visitor)` Alias of `C.Traversable.accept(Osgl.Function)`
`protected void`	`forEachLeft(Osgl.Func2<Integer,? super T,?> indexedVisitor)`
`protected void`	`forEachLeft(Osgl.Function<? super T,?> visitor)`
`protected void`	`forEachRight(Osgl.Func2<Integer,? super T,?> indexedVisitor)`
`protected void`	`forEachRight(Osgl.Function<? super T,?> visitor)`
`T`	`get()`
`T`	`get(int index)`
`int`	`hashCode()`
`T`	`head()` Returns an `$.Option` of the first element in the `Sequence` or `Osgl.NONE` if the `Sequence` is empty
`int`	`indexOf(Object o)`
`protected EnumSet<C.Feature>`	`initFeatures()` Sub class should override this method to provide initial feature set for the feature based instance
`C.List<T>`	`insert(int index, List<T> subList)` Insert a sub list at the position specified by `index`.
`C.List<T>`	`insert(int index, T... ta)` Insert an array of elements at the position specified by `index`.
`C.List<T>`	`insert(int index, T t)` Insert an element at the position specified by `index`.
`boolean`	`isDefined()`
`boolean`	`isEmpty()` Is this traversal empty?
`boolean`	`isNull()`
`Iterator<T>`	`iterator()`
`T`	`last()` Returns the last element from this `Sequence`
`int`	`lastIndexOf(Object o)`
`Osgl.Var<T>`	`lazy()` Returns this traversable and make sure `C.Feature.LAZY` is set
`ListIterator<T>`	`listIterator()`
`ListIterator<T>`	`listIterator(int index)`
`C.List.Cursor<T>`	`locate(Osgl.Function<T,Boolean> predicate)` Locate any one element in the list that matches the predicate.
`C.List.Cursor<T>`	`locateFirst(Osgl.Function<T,Boolean> predicate)` Find the first element in this list that matches the predicate.
`C.List.Cursor<T>`	`locateLast(Osgl.Function<T,Boolean> predicate)` Locate the first element in this list that matches the predicate.
`<R> C.ListOrSet<R>`	`map(Osgl.Function<? super T,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`boolean`	`noneMatch(Osgl.Function<? super T,Boolean> predicate)` Check if no elements matches the predicate specified.
`static <T> Osgl.Var<T>`	`of(T t)`
`C.Set<T>`	`onlyIn(Collection<? extends T> col)` Returns a set contains all elements in the `col` collection specified but not in this set
`Osgl.Var<T>`	`parallel()` Returns this traversable and make sure `C.Feature.PARALLEL` is set
`Osgl.Option<T>`	`reduce(Osgl.Func2<T,T,T> accumulator)` Performs a reduction on the elements in this traversable, using provided accumulating function.
`<R> R`	`reduce(R identity, Osgl.Func2<R,T,R> accumulator)` Performs a reduction on the elements in this traversable, using the provided identity and accumulating function.
`Osgl.Option<T>`	`reduceLeft(Osgl.Func2<T,T,T> accumulator)` Run reduction from head to tail.
`<R> R`	`reduceLeft(R identity, Osgl.Func2<R,T,R> accumulator)` Run reduction from header side.
`Osgl.Option<T>`	`reduceRight(Osgl.Func2<T,T,T> accumulator)` Run reduction from tail to head.
`<R> R`	`reduceRight(R identity, Osgl.Func2<R,T,R> accumulator)` Run reduction from tail side.
`T`	`remove(int index)`
`boolean`	`remove(Object o)`
`C.List<T>`	`remove(Osgl.Function<? super T,Boolean> predicate)` For mutable list, remove all element that matches the predicate specified from this List and return this list once done.
`boolean`	`removeAll(Collection<?> c)`
`protected void`	`removeRange(int fromIndex, int toIndex)`
`boolean`	`retainAll(Collection<?> c)`
`C.List<T>`	`reverse()` Returns an new `Sequence` that reverse this `Sequence`.
`Iterator<T>`	`reverseIterator()` Returns an `Iterator` iterate the sequence from tail to head
`Osgl.Var<T>`	`sequential()` Returns this traversable and make sure `C.Feature.PARALLEL` is unset
`T`	`set(int index, T element)`
`Osgl.Var<T>`	`set(Osgl.Var<T> var)`
`Osgl.Var<T>`	`set(T value)`
`int`	`size()` Return the size of this traversal
`C.List<T>`	`subList(int fromIndex, int toIndex)`
`C.List<T>`	`tail()` Returns the rest part of the `Sequence` except the first element
`C.List<T>`	`tail(int n)` Returns a `Sequence` consisting the last `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.List<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.List<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`:
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`Osgl.Option<T>`	`toOption()`
`Osgl.Var<T>`	`update(Osgl.Func0<T> changer)`
`Osgl.Var<T>`	`update(Osgl.Function<T,T> changer)`
`C.Set<T>`	`withIn(Collection<T> col)` Returns a set contains only elements in both `col` collection specified and this set
`C.ListOrSet<T>`	`without(Collection<? super T> col)` Returns a List contains all elements in this List and not in the `col` collection specified
`C.ListOrSet<T>`	`without(T element)` Returns a list contains all elements in the list except the one specified
`C.ListOrSet<T>`	`without(T element, T... elements)` Returns a list contains all elements in the list except the ones specified
`<E> C.List<Osgl.T2<T,E>>`	`zip(Iterable<E> iterable)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<B> C.List<Osgl.T2<T,B>>`	`zip(List<B> list)` Returns a list formed from this list 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.ListBase
accept, acceptLeft, append, append, append, append, append, append, append, append, appendList, appendReversibleSeq, copy, count, each, features_, features, first, forEach, head, is, isImmutable, isLazy, isMutable, isReadOnly, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prependList, prependReversibleSeq, readOnly, setFeature, snapshot, sorted, sorted, split, unique, unique, unsetFeature, zip, zipAll, zipAll, zipAll

Methods inherited from class java.util.AbstractCollection
toString

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

Methods inherited from interface org.osgl.util.C.List
accept, acceptLeft, append, append, append, copy, each, forEach, head, prepend, prepend, prepend, readOnly, snapshot, sorted, sorted, split, unique, unique, zipAll

Methods inherited from interface java.util.List
replaceAll, sort, spliterator

Methods inherited from interface org.osgl.util.C.ReversibleSequence
append, prepend, zip, zipAll

Methods inherited from interface org.osgl.util.C.Sequence
append, append, append, append, count, first, prepend, prepend, prepend, prepend, zipAll

Methods inherited from interface java.lang.Iterable
forEach

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

Methods inherited from interface java.util.Set
spliterator

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

- Field Detail
  - f
```
public Osgl.Var._f f
```
- Constructor Detail
  - Var
```
public Var(T value)
```
- Method Detail
  - isDefined
```
public final boolean isDefined()
```
  - isNull
```
public final boolean isNull()
```
  - apply
```
public T apply()
        throws NotAppliedException,
               Osgl.Break
```
    Description copied from interface: Osgl.Func0
    
    user application to implement main logic of applying the function
    
    Specified by:
    
    apply in interface Osgl.Func0<T>
    
    Returns:
    
    the Result instance of type R after appplying the function
    
    Throws:
    
    NotAppliedException - if the function doesn't apply to the current context
    
    Osgl.Break - to short cut collecting operations (fold/reduce) on an container
  - initFeatures
```
protected EnumSet<C.Feature> initFeatures()
```
    Description copied from class: ListBase
    
    Sub class should override this method to provide initial feature set for the feature based instance
    
    Specified by:
    
    initFeatures in class ListBase<T>
    
    Returns:
    
    the initial feature set configuration
  - accept
```
public Osgl.Var<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.List<T>
    
    Specified by:
    
    accept in interface C.ListOrSet<T>
    
    Specified by:
    
    accept in interface C.ReversibleSequence<T>
    
    Specified by:
    
    accept in interface C.Sequence<T>
    
    Specified by:
    
    accept in interface C.Set<T>
    
    Specified by:
    
    accept in interface C.Traversable<T>
    
    Overrides:
    
    accept in class ListBase<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
  - each
```
public Osgl.Var<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.List<T>
    
    Specified by:
    
    each in interface C.ListOrSet<T>
    
    Specified by:
    
    each in interface C.ReversibleSequence<T>
    
    Specified by:
    
    each in interface C.Sequence<T>
    
    Specified by:
    
    each in interface C.Set<T>
    
    Specified by:
    
    each in interface C.Traversable<T>
    
    Overrides:
    
    each in class ListBase<T>
    
    Parameters:
    
    visitor - the visitor to tranverse the elements
    
    Returns:
    
    this Traversable instance
  - forEach
```
public Osgl.Var<T> forEach(Osgl.Function<? super T,?> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Osgl.Function)
    
    Specified by:
    
    forEach in interface C.List<T>
    
    Specified by:
    
    forEach in interface C.ListOrSet<T>
    
    Specified by:
    
    forEach in interface C.ReversibleSequence<T>
    
    Specified by:
    
    forEach in interface C.Sequence<T>
    
    Specified by:
    
    forEach in interface C.Set<T>
    
    Specified by:
    
    forEach in interface C.Traversable<T>
    
    Overrides:
    
    forEach in class ListBase<T>
    
    Parameters:
    
    visitor - the visitor function
    
    Returns:
    
    this Traversable instance
  - head
```
public 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>
    
    Overrides:
    
    head in class ListBase<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 Osgl.Var<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.List<T>
    
    Specified by:
    
    acceptLeft in interface C.ReversibleSequence<T>
    
    Specified by:
    
    acceptLeft in interface C.Sequence<T>
    
    Overrides:
    
    acceptLeft in class ListBase<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)
```
    Description copied from interface: C.Sequence
    Run reduction from header side. This is equivalent to:
```
      R result = identity;
      for (T element: this sequence) {
          result = accumulator.apply(result, element);
      }
      return result;
 
```
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Overrides:
    
    reduceLeft in class ListBase<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)
```
    Description copied from interface: C.Sequence
    Run reduction from head to tail. This is equivalent to
```
      if (isEmpty()) {
          return _.none();
      }
      T result = head();
      for (T element: this traversable.tail()) {
          result = accumulator.apply(result, element);
      }
      return _.some(result);
 
```
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Overrides:
    
    reduceLeft in class ListBase<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)
```
    Description copied from interface: C.Sequence
    
    Apply the predicate specified to the element of this sequence from head to tail. Stop at the element that returns true, and returns an $.Option describing the element. If none of the element applications in the sequence returns true then Osgl.none() is returned
    
    Specified by:
    
    findFirst in interface C.Sequence<T>
    
    Overrides:
    
    findFirst in class ListBase<T>
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Osgl.none()
  - take
```
public C.List<T> take(int n)
```
    Description copied from interface: C.List
    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));
 
```
    This method does not alter the underline list
    Specified by:
    
    take in interface C.List<T>
    
    Specified by:
    
    take in interface C.ReversibleSequence<T>
    
    Specified by:
    
    take in interface C.Sequence<T>
    
    Overrides:
    
    take in class ListBase<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence
    
    Returns:
    
    A list contains first n items in this list
    
    See Also:
    
    C.Sequence.head(int)
  - tail
```
public C.List<T> tail()
               throws UnsupportedOperationException
```
    Description copied from interface: C.List
    
    Returns the rest part of the Sequence except the first element
    
    Specified by:
    
    tail in interface C.List<T>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<T>
    
    Specified by:
    
    tail in interface C.Sequence<T>
    
    Overrides:
    
    tail in class ListBase<T>
    
    Returns:
    
    A list contains all elements in this list except the first one
    
    Throws:
    
    UnsupportedOperationException - if the Sequence is empty
    
    See Also:
    
    C.Sequence.head(), C.ReversibleSequence.tail(int)
  - takeWhile
```
public C.List<T> takeWhile(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    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)));
 
```
    This method does not alter the underline list
    Specified by:
    
    takeWhile in interface C.List<T>
    
    Specified by:
    
    takeWhile in interface C.ReversibleSequence<T>
    
    Specified by:
    
    takeWhile in interface C.Sequence<T>
    
    Overrides:
    
    takeWhile in class ListBase<T>
    
    Parameters:
    
    predicate - specify which the elements in this Sequence will put into the new Sequence
    
    Returns:
    
    an new reversible sequence contains the elements in this sequence until predicate evaluate to false
  - drop
```
public C.List<T> drop(int n)
               throws IllegalArgumentException
```
    Description copied from interface: C.List
    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
    
    This method does not alter the underline list
    Specified by:
    
    drop in interface C.List<T>
    
    Specified by:
    
    drop in interface C.ReversibleSequence<T>
    
    Specified by:
    
    drop in interface C.Sequence<T>
    
    Overrides:
    
    drop in class ListBase<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence or the -n number of elements to be taken from the tail of this sequence if n is an negative number
    
    Returns:
    
    a List contains all elements of this list except the first n number
    
    Throws:
    
    IllegalArgumentException
  - dropWhile
```
public C.List<T> dropWhile(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    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
    
    This method does not alter the underline list
    Specified by:
    
    dropWhile in interface C.List<T>
    
    Specified by:
    
    dropWhile in interface C.ReversibleSequence<T>
    
    Specified by:
    
    dropWhile in interface C.Sequence<T>
    
    Overrides:
    
    dropWhile in class ListBase<T>
    
    Parameters:
    
    predicate - the predicate function
    
    Returns:
    
    the sequence after applying the drop operations
  - filter
```
public C.ListOrSet<T> filter(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    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.List<T>
    
    Specified by:
    
    filter in interface C.ListOrSet<T>
    
    Specified by:
    
    filter in interface C.ReversibleSequence<T>
    
    Specified by:
    
    filter in interface C.Sequence<T>
    
    Specified by:
    
    filter in interface C.Set<T>
    
    Specified by:
    
    filter in interface C.Traversable<T>
    
    Overrides:
    
    filter in class ListBase<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:
    
    An new Sequence consists of elements that passed the predicate
  - map
```
public <R> C.ListOrSet<R> map(Osgl.Function<? super T,? extends R> mapper)
```
    Description copied from interface: C.Sequence
    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.List<T>
    
    Specified by:
    
    map in interface C.ListOrSet<T>
    
    Specified by:
    
    map in interface C.ReversibleSequence<T>
    
    Specified by:
    
    map in interface C.Sequence<T>
    
    Specified by:
    
    map in interface C.Traversable<T>
    
    Overrides:
    
    map in class ListBase<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:
    
    a Sequence of R that are mapped from this sequence
  - flatMap
```
public <R> C.List<R> flatMap(Osgl.Function<? super T,? extends Iterable<? extends R>> mapper)
```
    Description copied from interface: C.List
    
    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.List<T>
    
    Specified by:
    
    flatMap in interface C.ReversibleSequence<T>
    
    Specified by:
    
    flatMap in interface C.Sequence<T>
    
    Specified by:
    
    flatMap in interface C.Traversable<T>
    
    Overrides:
    
    flatMap in class ListBase<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:
    
    a List of R type element that are mapped from this sequences
  - zip
```
public <E> C.List<Osgl.T2<T,E>> zip(Iterable<E> 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>
    
    Overrides:
    
    zip in class ListBase<T>
    
    Type Parameters:
    
    E - 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.
  - zipWithIndex
```
public C.Sequence<Osgl.T2<T,Integer>> zipWithIndex()
```
    Description copied from interface: C.List
    
    Zip this sequence with its indices
    
    Specified by:
    
    zipWithIndex in interface C.List<T>
    
    Specified by:
    
    zipWithIndex in interface C.Sequence<T>
    
    Overrides:
    
    zipWithIndex in class ListBase<T>
    
    Returns:
    
    A new list containing pairs consisting of all elements of this list paired with their index. Indices start at 0.
  - lazy
```
public Osgl.Var<T> lazy()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is set
    
    Specified by:
    
    lazy in interface C.List<T>
    
    Specified by:
    
    lazy in interface C.ListOrSet<T>
    
    Specified by:
    
    lazy in interface C.ReversibleSequence<T>
    
    Specified by:
    
    lazy in interface C.Sequence<T>
    
    Specified by:
    
    lazy in interface C.Set<T>
    
    Specified by:
    
    lazy in interface C.Traversable<T>
    
    Overrides:
    
    lazy in class ListBase<T>
    
    Returns:
    
    this reference with lazy turned on
  - eager
```
public Osgl.Var<T> eager()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is unset
    
    Specified by:
    
    eager in interface C.List<T>
    
    Specified by:
    
    eager in interface C.ListOrSet<T>
    
    Specified by:
    
    eager in interface C.ReversibleSequence<T>
    
    Specified by:
    
    eager in interface C.Sequence<T>
    
    Specified by:
    
    eager in interface C.Set<T>
    
    Specified by:
    
    eager in interface C.Traversable<T>
    
    Overrides:
    
    eager in class ListBase<T>
    
    Returns:
    
    this reference with lazy turned off
  - parallel
```
public Osgl.Var<T> parallel()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.PARALLEL is set
    
    Specified by:
    
    parallel in interface C.List<T>
    
    Specified by:
    
    parallel in interface C.ListOrSet<T>
    
    Specified by:
    
    parallel in interface C.ReversibleSequence<T>
    
    Specified by:
    
    parallel in interface C.Sequence<T>
    
    Specified by:
    
    parallel in interface C.Set<T>
    
    Specified by:
    
    parallel in interface C.Traversable<T>
    
    Overrides:
    
    parallel in class ListBase<T>
    
    Returns:
    
    this reference with parallel turned on
  - sequential
```
public Osgl.Var<T> sequential()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.PARALLEL is unset
    
    Specified by:
    
    sequential in interface C.List<T>
    
    Specified by:
    
    sequential in interface C.ListOrSet<T>
    
    Specified by:
    
    sequential in interface C.ReversibleSequence<T>
    
    Specified by:
    
    sequential in interface C.Sequence<T>
    
    Specified by:
    
    sequential in interface C.Set<T>
    
    Specified by:
    
    sequential in interface C.Traversable<T>
    
    Overrides:
    
    sequential in class ListBase<T>
    
    Returns:
    
    this reference with parallel turned off
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<T>
    
    Specified by:
    
    hashCode in interface List<T>
    
    Specified by:
    
    hashCode in interface Set<T>
    
    Overrides:
    
    hashCode in class ListBase<T>
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Collection<T>
    
    Specified by:
    
    equals in interface List<T>
    
    Specified by:
    
    equals in interface Set<T>
    
    Overrides:
    
    equals in class ListBase<T>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: C.Traversable
    
    Is this traversal empty?
    
    Specified by:
    
    isEmpty in interface Collection<T>
    
    Specified by:
    
    isEmpty in interface List<T>
    
    Specified by:
    
    isEmpty in interface Set<T>
    
    Specified by:
    
    isEmpty in interface C.Traversable<T>
    
    Overrides:
    
    isEmpty in class AbstractCollection<T>
    
    Returns:
    
    true if the traversal is empty or false otherwise
  - reduce
```
public <R> R reduce(R identity,
                    Osgl.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.Sequence
    Performs a reduction on the elements in this traversable, using the provided identity and accumulating function. This might be equivalent to:
```
      R result = identity;
      for (T element: this traversable) {
          result = accumulator.apply(result, element);
      }
      return result;
 
```
    The above shows a typical left side reduce. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    This method does not specify how to run the accumulator. It might be C.Sequence.reduceLeft(Object, Osgl.Func2) or C.ReversibleSequence.reduceRight(Object, Osgl.Func2), or even run reduction in parallel, it all depending on the implementation.
    For a guaranteed reduce from left to right, use C.Sequence.reduceLeft(Object, Osgl.Func2) instead
    Specified by:
    
    reduce in interface C.Sequence<T>
    
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Overrides:
    
    reduce in class ListBase<T>
    
    Type Parameters:
    
    R - the type of identity and the return value
    
    Parameters:
    
    identity - the identity value for the accumulating function
    
    accumulator - the function the combine two values
    
    Returns:
    
    the result of reduction
  - reduce
```
public Osgl.Option<T> reduce(Osgl.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.Sequence
    Performs a reduction on the elements in this traversable, using provided accumulating function. This might be equivalent to:
```
      boolean found = false;
      T result = null;
      for (T element: this traversable) {
          if (found) {
              result = accumulator.apply(result, element);
          } else {
              found = true;
              result = element;
          }
      }
      return found ? _.some(result) : _.none();
 
```
    The above shows a typical left side reduction. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    This method does not specify the approach to run reduction. For a guaranteed reduction from head to tail, use C.Sequence.reduceLeft(Osgl.Func2) instead
    Specified by:
    
    reduce in interface C.Sequence<T>
    
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Overrides:
    
    reduce in class ListBase<T>
    
    Parameters:
    
    accumulator - the function takes previous accumulating result and the current element being iterated
    
    Returns:
    
    an option describing the accumulating result or Osgl.none() if the structure is empty
  - findOne
```
public Osgl.Option<T> findOne(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Returns an element that matches the predicate specified. The interface does not indicate if it should be the first element matches the predicate be returned or in case of parallel computing, whatever element matches found first is returned. It's all up to the implementation to refine the semantic of this method
    
    Specified by:
    
    findOne in interface C.Traversable<T>
    
    Overrides:
    
    findOne in class ListBase<T>
    
    Parameters:
    
    predicate - the function map element to Boolean
    
    Returns:
    
    an element in this traversal that matches the predicate or Osgl.NONE if no element matches
  - anyMatch
```
public boolean anyMatch(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if any elements matches the predicate specified
    
    Specified by:
    
    anyMatch in interface C.Traversable<T>
    
    Overrides:
    
    anyMatch in class ListBase<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if any element matches the predicate
  - noneMatch
```
public boolean noneMatch(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    Check if no elements matches the predicate specified. This should be equivalent to:
```
      this.allMatch(_.F.negate(predicate));
 
```
    Specified by:
    
    noneMatch in interface C.Traversable<T>
    
    Overrides:
    
    noneMatch in class ListBase<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if none element matches the predicate
  - allMatch
```
public boolean allMatch(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if all elements match the predicate specified
    
    Specified by:
    
    allMatch in interface C.Traversable<T>
    
    Overrides:
    
    allMatch in class ListBase<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if all elements match the predicate
  - size
```
public int size()
         throws UnsupportedOperationException
```
    Description copied from interface: C.Traversable
    
    Return the size of this traversal
    
    Specified by:
    
    size in interface Collection<T>
    
    Specified by:
    
    size in interface List<T>
    
    Specified by:
    
    size in interface Set<T>
    
    Specified by:
    
    size in interface C.Traversable<T>
    
    Specified by:
    
    size in class AbstractCollection<T>
    
    Returns:
    
    the size of the structure
    
    Throws:
    
    UnsupportedOperationException - if this structure does not support this method
  - subList
```
public C.List<T> subList(int fromIndex,
                         int toIndex)
```
    Specified by:
    
    subList in interface List<T>
    
    Specified by:
    
    subList in interface C.List<T>
    
    Overrides:
    
    subList in class ListBase<T>
  - addAll
```
public boolean addAll(Iterable<? extends T> iterable)
```
    Description copied from interface: C.List
    
    Add all elements from an Iterable into this list. Return true if the list has changed as a result of call.
    Note if this list is immutable or readonly, UnsupportedOperationException will be thrown out with this call
    
    Specified by:
    
    addAll in interface C.List<T>
    
    Overrides:
    
    addAll in class ListBase<T>
    
    Parameters:
    
    iterable - the iterable provides the elements to be added into the list
    
    Returns:
    
    true if this list changed as result of addd
  - tail
```
public C.List<T> tail(int n)
```
    Description copied from interface: C.List
    Returns a Sequence consisting the last 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 first -n elements from this Sequence is returned in an new Sequence
```
     Sequence seq = C1.list(1, 2, 3, 4);
     assertEquals(C1.list(3, 4), seq.tail(2));
     assertEquals(C1.list(1, 2, 3, 4), seq.tail(100));
     assertEquals(C1.list(), seq.tail(0));
     assertEquals(C1.list(1, 2, 3), seq.tail(-3));
     assertEquals(C1.list(1, 2, 3, 4), seq.tail(-200));
 
```
    This method does not mutate the underline container
    
    This method does not alter the underline list
    Specified by:
    
    tail in interface C.List<T>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<T>
    
    Overrides:
    
    tail in class ListBase<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the tail of this Sequence
    
    Returns:
    
    A list contains last n items in this list
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - remove
```
public C.List<T> remove(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    For mutable list, remove all element that matches the predicate specified from this List and return this list once done.
    For immutable or readonly list, an new List contains all element from this list that does not match the predicate specified is returned
    
    Specified by:
    
    remove in interface C.List<T>
    
    Overrides:
    
    remove in class ListBase<T>
    
    Parameters:
    
    predicate - test whether an element should be removed frmo return list
    
    Returns:
    
    a list contains all element that does not match the predicate specified
  - locateFirst
```
public C.List.Cursor<T> locateFirst(Osgl.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Find the first element in this list that matches the predicate. Return a cursor point to the location of the element. If no such element is found then a cursor that point to -1 is returned.
    
    Specified by:
    
    locateFirst in interface C.List<T>
    
    Overrides:
    
    locateFirst in class ListBase<T>
    
    Parameters:
    
    predicate - test the element
    
    Returns:
    
    the reference to the list itself or an new List without the first element matches the predicate if this is a readonly list
  - locate
```
public C.List.Cursor<T> locate(Osgl.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Locate any one element in the list that matches the predicate. Returns the cursor point to the element found, or a cursor that is not defined if no such element found in the list. In a parallel locating the element been found might not be the first element matches the predicate
    
    Specified by:
    
    locate in interface C.List<T>
    
    Overrides:
    
    locate in class ListBase<T>
    
    Parameters:
    
    predicate - the function that used to check the element at the cursor
    
    Returns:
    
    the reference to the list itself or an new List without and element matches the predicate if this is a readonly list
  - locateLast
```
public C.List.Cursor<T> locateLast(Osgl.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Locate the first element in this list that matches the predicate. Return a cursor point to the location of the element. If no such element is found then a cursor that point to -1 is returned.
    
    Specified by:
    
    locateLast in interface C.List<T>
    
    Overrides:
    
    locateLast in class ListBase<T>
    
    Parameters:
    
    predicate - test the element
    
    Returns:
    
    the reference to the list itself or an new List without the first element matches the predicate if this is a readonly list
  - insert
```
public C.List<T> insert(int index,
                        T t)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert an element at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the new element inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Overrides:
    
    insert in class ListBase<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    t - the element to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - insert
```
public C.List<T> insert(int index,
                        T... ta)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert an array of elements at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the new element inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Overrides:
    
    insert in class ListBase<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    ta - the array of elements to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - insert
```
public C.List<T> insert(int index,
                        List<T> subList)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert a sub list at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the elements of sub list inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Overrides:
    
    insert in class ListBase<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    subList - the sub list contains elements to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - reverse
```
public C.List<T> reverse()
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an new Sequence that reverse this Sequence.
    
    Specified by:
    
    reverse in interface C.List<T>
    
    Specified by:
    
    reverse in interface C.ReversibleSequence<T>
    
    Overrides:
    
    reverse in class ListBase<T>
    
    Returns:
    
    a reversed Sequence
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - without
```
public C.ListOrSet<T> without(Collection<? super T> col)
```
    Description copied from interface: C.List
    
    Returns a List contains all elements in this List and not in the col collection specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Specified by:
    
    without in interface C.ListOrSet<T>
    
    Specified by:
    
    without in interface C.Set<T>
    
    Overrides:
    
    without in class ListBase<T>
    
    Parameters:
    
    col - the collection in which elements should be excluded from the result List
    
    Returns:
    
    a List contains elements only in this list
  - without
```
public C.ListOrSet<T> without(T element)
```
    Description copied from interface: C.List
    
    Returns a list contains all elements in the list except the one specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Specified by:
    
    without in interface C.ListOrSet<T>
    
    Specified by:
    
    without in interface C.Set<T>
    
    Overrides:
    
    without in class ListBase<T>
    
    Parameters:
    
    element - the element that should not be in the resulting list
    
    Returns:
    
    a list without the element specified
  - without
```
public C.ListOrSet<T> without(T element,
                              T... elements)
```
    Description copied from interface: C.List
    
    Returns a list contains all elements in the list except the ones specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Specified by:
    
    without in interface C.ListOrSet<T>
    
    Specified by:
    
    without in interface C.Set<T>
    
    Overrides:
    
    without in class ListBase<T>
    
    Parameters:
    
    element - the element that should not be in the resulting list
    
    elements - the array contains elements that should not be in the resulting list
    
    Returns:
    
    a list without the element specified
  - onlyIn
```
public C.Set<T> onlyIn(Collection<? extends T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in the col collection specified but not in this set
    
    Specified by:
    
    onlyIn in interface C.Set<T>
    
    Parameters:
    
    col - the collection in which elements should be included from the result set
    
    Returns:
    
    a set contains elements only in the col
  - withIn
```
public C.Set<T> withIn(Collection<T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains only elements in both col collection specified and this set
    
    Specified by:
    
    withIn in interface C.Set<T>
    
    Parameters:
    
    col - the collection in which elements should be included from the result set
    
    Returns:
    
    a set contains elements in both col and this set
  - acceptRight
```
public C.List<T> acceptRight(Osgl.Function<? super T,?> visitor)
```
    Description copied from interface: C.ReversibleSequence
    
    Iterate through this sequence from tail to head with the visitor function specified
    
    Specified by:
    
    acceptRight in interface C.List<T>
    
    Specified by:
    
    acceptRight in interface C.ReversibleSequence<T>
    
    Overrides:
    
    acceptRight in class ListBase<T>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Osgl.Function), C.Sequence.acceptLeft(Osgl.Function)
  - acceptRight
```
public C.List<T> acceptRight(Osgl.Func2<Integer,? super T,?> indexedVisitor)
```
    Description copied from interface: C.List
    
    Loop through the list from size() - 1 to 0. Call the indexedVisitor function on each element along with the index
    
    Specified by:
    
    acceptRight in interface C.List<T>
    
    Overrides:
    
    acceptRight in class ListBase<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - forEachLeft
```
protected void forEachLeft(Osgl.Function<? super T,?> visitor)
                    throws Osgl.Break
```
    Overrides:
    
    forEachLeft in class ListBase<T>
    
    Throws:
    
    Osgl.Break
  - forEachLeft
```
protected void forEachLeft(Osgl.Func2<Integer,? super T,?> indexedVisitor)
                    throws Osgl.Break
```
    Overrides:
    
    forEachLeft in class ListBase<T>
    
    Throws:
    
    Osgl.Break
  - forEachRight
```
protected void forEachRight(Osgl.Function<? super T,?> visitor)
                     throws Osgl.Break
```
    Overrides:
    
    forEachRight in class ListBase<T>
    
    Throws:
    
    Osgl.Break
  - forEachRight
```
protected void forEachRight(Osgl.Func2<Integer,? super T,?> indexedVisitor)
                     throws Osgl.Break
```
    Overrides:
    
    forEachRight in class ListBase<T>
    
    Throws:
    
    Osgl.Break
  - zip
```
public <B> C.List<Osgl.T2<T,B>> zip(List<B> list)
```
    Description copied from interface: C.List
    
    Returns a list formed from this list 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.List<T>
    
    Overrides:
    
    zip in class ListBase<T>
    
    Type Parameters:
    
    B - the type of the iterable
    
    Parameters:
    
    list - the part B to be zipped with this list
    
    Returns:
    
    an new list 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.
  - add
```
public boolean add(T t)
```
    Specified by:
    
    add in interface Collection<T>
    
    Specified by:
    
    add in interface List<T>
    
    Specified by:
    
    add in interface Set<T>
    
    Overrides:
    
    add in class ListBase<T>
  - listIterator
```
public ListIterator<T> listIterator(int index)
```
    Specified by:
    
    listIterator in interface List<T>
    
    Specified by:
    
    listIterator in class ListBase<T>
  - listIterator
```
public ListIterator<T> listIterator()
```
    Specified by:
    
    listIterator in interface List<T>
    
    Overrides:
    
    listIterator in class AbstractList<T>
  - last
```
public T last()
       throws NoSuchElementException
```
    Description copied from interface: C.ReversibleSequence
    
    Returns the last element from this Sequence
    
    Specified by:
    
    last in interface C.ReversibleSequence<T>
    
    Overrides:
    
    last in class ListBase<T>
    
    Returns:
    
    the last element
    
    Throws:
    
    NoSuchElementException - if the Sequence is empty
    
    See Also:
    
    C.Traversable.isEmpty(), C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - reverseIterator
```
public Iterator<T> reverseIterator()
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an Iterator iterate the sequence from tail to head
    
    Specified by:
    
    reverseIterator in interface C.ReversibleSequence<T>
    
    Overrides:
    
    reverseIterator in class ListBase<T>
    
    Returns:
    
    the iterator
  - get
```
public T get(int index)
```
    Specified by:
    
    get in interface List<T>
    
    Specified by:
    
    get in class AbstractList<T>
  - get
```
public T get()
```
  - set
```
public Osgl.Var<T> set(T value)
```
  - set
```
public Osgl.Var<T> set(Osgl.Var<T> var)
```
  - set
```
public T set(int index,
             T element)
```
    Specified by:
    
    set in interface List<T>
    
    Overrides:
    
    set in class AbstractList<T>
  - add
```
public void add(int index,
                T element)
```
    Specified by:
    
    add in interface List<T>
    
    Overrides:
    
    add in class ListBase<T>
  - remove
```
public T remove(int index)
```
    Specified by:
    
    remove in interface List<T>
    
    Overrides:
    
    remove in class AbstractList<T>
  - indexOf
```
public int indexOf(Object o)
```
    Specified by:
    
    indexOf in interface List<T>
    
    Overrides:
    
    indexOf in class AbstractList<T>
  - lastIndexOf
```
public int lastIndexOf(Object o)
```
    Specified by:
    
    lastIndexOf in interface List<T>
    
    Overrides:
    
    lastIndexOf in class AbstractList<T>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<T>
    
    Specified by:
    
    clear in interface List<T>
    
    Specified by:
    
    clear in interface Set<T>
    
    Overrides:
    
    clear in class AbstractList<T>
  - addAll
```
public boolean addAll(int index,
                      Collection<? extends T> c)
```
    Specified by:
    
    addAll in interface List<T>
    
    Overrides:
    
    addAll in class AbstractList<T>
  - removeRange
```
protected void removeRange(int fromIndex,
                           int toIndex)
```
    Overrides:
    
    removeRange in class AbstractList<T>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<T>
    
    Specified by:
    
    contains in interface List<T>
    
    Specified by:
    
    contains in interface Set<T>
    
    Overrides:
    
    contains in class AbstractCollection<T>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<T>
    
    Specified by:
    
    toArray in interface List<T>
    
    Specified by:
    
    toArray in interface Set<T>
    
    Overrides:
    
    toArray in class AbstractCollection<T>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<T>
    
    Specified by:
    
    toArray in interface List<T>
    
    Specified by:
    
    toArray in interface Set<T>
    
    Overrides:
    
    toArray in class AbstractCollection<T>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<T>
    
    Specified by:
    
    remove in interface List<T>
    
    Specified by:
    
    remove in interface Set<T>
    
    Overrides:
    
    remove in class AbstractCollection<T>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<T>
    
    Specified by:
    
    containsAll in interface List<T>
    
    Specified by:
    
    containsAll in interface Set<T>
    
    Overrides:
    
    containsAll in class AbstractCollection<T>
  - addAll
```
public boolean addAll(Collection<? extends T> c)
```
    Specified by:
    
    addAll in interface Collection<T>
    
    Specified by:
    
    addAll in interface List<T>
    
    Specified by:
    
    addAll in interface Set<T>
    
    Overrides:
    
    addAll in class AbstractCollection<T>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<T>
    
    Specified by:
    
    removeAll in interface List<T>
    
    Specified by:
    
    removeAll in interface Set<T>
    
    Overrides:
    
    removeAll in class AbstractCollection<T>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<T>
    
    Specified by:
    
    retainAll in interface List<T>
    
    Specified by:
    
    retainAll in interface Set<T>
    
    Overrides:
    
    retainAll in class AbstractCollection<T>
  - reduceRight
```
public <R> R reduceRight(R identity,
                         Osgl.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.ReversibleSequence
    Run reduction from tail side. This is equivalent to:
```
      R result = identity;
      for (T element: this sequence.reverse()) {
          result = accumulator.apply(result, element);
      }
      return result;
 
```
    Specified by:
    
    reduceRight in interface C.ReversibleSequence<T>
    
    Overrides:
    
    reduceRight in class ListBase<T>
    
    Type Parameters:
    
    R - the accumulation result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the function performs accumulation from T an R to anthoer R
    
    Returns:
    
    the aggregation result
    
    See Also:
    
    C.Sequence.reduce(Object, Osgl.Func2)
  - reduceRight
```
public Osgl.Option<T> reduceRight(Osgl.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.ReversibleSequence
    Run reduction from tail to head. This is equivalent to
```
      if (isEmpty()) {
          return _.none();
      }
      T result = last();
      for (T element: this sequence.reverse.tail()) {
          result = accumulator.apply(result, element);
      }
      return _.some(result);
 
```
    Specified by:
    
    reduceRight in interface C.ReversibleSequence<T>
    
    Overrides:
    
    reduceRight in class ListBase<T>
    
    Parameters:
    
    accumulator - the function accumulate each element to the final result
    
    Returns:
    
    an $.Option describing the accumulating result
  - findLast
```
public Osgl.Option<T> findLast(Osgl.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.ReversibleSequence
    
    Apply the predicate specified to the element of this sequence from tail to head. Stop at the element that returns true, and returns an $.Option describing the element. If none of the element applications in the sequence returns true then Osgl.none() is returned
    
    Specified by:
    
    findLast in interface C.ReversibleSequence<T>
    
    Overrides:
    
    findLast in class ListBase<T>
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Osgl.none()
  - iterator
```
public Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface Iterable<T>
    
    Specified by:
    
    iterator in interface Collection<T>
    
    Specified by:
    
    iterator in interface List<T>
    
    Specified by:
    
    iterator in interface Set<T>
    
    Overrides:
    
    iterator in class ListBase<T>
  - update
```
public Osgl.Var<T> update(Osgl.Function<T,T> changer)
```
  - update
```
public Osgl.Var<T> update(Osgl.Func0<T> changer)
```
  - toOption
```
public Osgl.Option<T> toOption()
```
  - of
```
public static <T> Osgl.Var<T> of(T t)
```

Class Osgl.Var<T>

Nested Class Summary

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

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

Field Summary

Fields inherited from class java.util.AbstractList

Constructor Summary

Method Summary

Methods inherited from class org.osgl.util.ListBase

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.List

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

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

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface java.util.Set

Methods inherited from interface java.util.Collection

Field Detail

f

Constructor Detail

Var

Method Detail

isDefined

isNull

apply

initFeatures

accept

each

forEach

head

acceptLeft

reduceLeft

reduceLeft

findFirst

take

tail

takeWhile

drop

dropWhile

filter

map

flatMap

zip

zipWithIndex

lazy

eager

parallel

sequential

hashCode

equals

isEmpty

reduce

reduce

findOne

anyMatch

noneMatch

allMatch

size

subList

addAll

tail

remove

locateFirst

locate

locateLast

insert

insert

insert

reverse

without

without

without

onlyIn

withIn

acceptRight

acceptRight

forEachLeft

forEachLeft