C.ReversibleSequence (Java Tool 1.20.2 API)

Type Parameters:

T - the element type

All Superinterfaces:

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

All Known Subinterfaces:

C.List<T>, C.ListOrSet<T>, S.List

All Known Implementing Classes:

C.Array, CompositeList, FastStr, Lang.Val, Lang.Var, ListBase, S.Val, S.Var, Str, StrBase

Enclosing class:

C
```
public static interface C.ReversibleSequence<T>
extends C.Sequence<T>
```
A bidirectional sequence which can be iterated from tail to head

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

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`C.ReversibleSequence<T>`	`accept(Lang.Visitor<? super T> visitor)` Iterate this `Traversable` with a visitor function.
`C.ReversibleSequence<T>`	`acceptLeft(Lang.Visitor<? super T> visitor)` Iterate through this sequence from head to tail with the visitor function specified
`C.ReversibleSequence<T>`	`acceptRight(Lang.Visitor<? super T> visitor)` Iterate through this sequence from tail to head with the visitor function specified
`C.ReversibleSequence<T>`	`append(C.ReversibleSequence<T> seq)` Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence
`C.ReversibleSequence<T>`	`append(T t)` Returns a sequence consists of all elements of this sequence followed by the element specified.
`C.ReversibleSequence<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.ReversibleSequence<T>`	`dropWhile(Lang.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.ReversibleSequence<T>`	`each(Lang.Visitor<? super T> visitor)` Alias of `C.Traversable.accept(Lang.Visitor)`
`C.ReversibleSequence<T>`	`eager()` Returns this traversable and make sure `C.Feature.LAZY` is unset
`C.ReversibleSequence<T>`	`filter(Lang.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.
`Lang.Option<T>`	`findLast(Lang.Function<? super T,Boolean> predicate)` Apply the predicate specified to the element of this sequence from tail to head.
`<R> C.ReversibleSequence<R>`	`flatMap(Lang.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.
`C.ReversibleSequence<T>`	`forEach(Lang.Visitor<? super T> visitor)` Alias of `C.Traversable.accept(Lang.Visitor)`
`C.ReversibleSequence<T>`	`head(int n)` Alias of `C.Sequence.take(int)`
`T`	`last()` Returns the last element from this `Sequence`
`C.ReversibleSequence<T>`	`lazy()` Returns this traversable and make sure `C.Feature.LAZY` is set
`<R> C.ReversibleSequence<R>`	`map(Lang.Function<? super T,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`C.ReversibleSequence<T>`	`parallel()` Returns this traversable and make sure `C.Feature.PARALLEL` is set
`C.ReversibleSequence<T>`	`prepend(C.ReversibleSequence<T> seq)` Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence
`C.ReversibleSequence<T>`	`prepend(T t)` Returns a sequence consists of the element specified followed by all elements of this sequence.
`Lang.Option<T>`	`reduceRight(Lang.Func2<T,T,T> accumulator)` Run reduction from tail to head.
`<R> R`	`reduceRight(R identity, Lang.Func2<R,T,R> accumulator)` Run reduction from tail side.
`C.ReversibleSequence<T>`	`reverse()` Returns an new `Sequence` that reverse this `Sequence`.
`Iterator<T>`	`reverseIterator()` Returns an `Iterator` iterate the sequence from tail to head
`C.ReversibleSequence<T>`	`sequential()` Returns this traversable and make sure `C.Feature.PARALLEL` is unset
`C.ReversibleSequence<T>`	`tail()` Returns the rest part of the `Sequence` except the first element
`C.ReversibleSequence<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.ReversibleSequence<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.ReversibleSequence<T>`	`takeWhile(Lang.Function<? super T,Boolean> predicate)` Returns an new `Sequence` that takes the head of this `Sequence` until the predicate evaluate to `false`:
`<T2> C.ReversibleSequence<Lang.Binary<T,T2>>`	`zip(C.ReversibleSequence<T2> rseq)`
`<T2> C.ReversibleSequence<Lang.Binary<T,T2>>`	`zipAll(C.ReversibleSequence<T2> rseq, T def1, T2 def2)`

Methods inherited from interface org.osgl.util.C.Sequence
append, append, append, append, asList, collect, count, findFirst, first, head, prepend, prepend, prepend, prepend, reduce, reduce, reduceLeft, reduceLeft, zip, zipAll, zipWithIndex

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

- Method Detail
  - parallel
```
C.ReversibleSequence<T> parallel()
```
    Returns this traversable and make sure C.Feature.PARALLEL is set
    
    Specified by:
    
    parallel in interface C.Sequence<T>
    
    Specified by:
    
    parallel in interface C.Traversable<T>
    
    Returns:
    
    this reference with parallel turned on
  - sequential
```
C.ReversibleSequence<T> sequential()
```
    Returns this traversable and make sure C.Feature.PARALLEL is unset
    
    Specified by:
    
    sequential in interface C.Sequence<T>
    
    Specified by:
    
    sequential in interface C.Traversable<T>
    
    Returns:
    
    this reference with parallel turned off
  - lazy
```
C.ReversibleSequence<T> lazy()
```
    Returns this traversable and make sure C.Feature.LAZY is set
    
    Specified by:
    
    lazy in interface C.Sequence<T>
    
    Specified by:
    
    lazy in interface C.Traversable<T>
    
    Returns:
    
    this reference with lazy turned on
  - eager
```
C.ReversibleSequence<T> eager()
```
    Returns this traversable and make sure C.Feature.LAZY is unset
    
    Specified by:
    
    eager in interface C.Sequence<T>
    
    Specified by:
    
    eager in interface C.Traversable<T>
    
    Returns:
    
    this reference with lazy turned off
  - head
```
C.ReversibleSequence<T> head(int n)
```
    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:
    
    an new reversible sequence contains the first n elements in this sequence
  - tail
```
C.ReversibleSequence<T> tail()
```
    Returns the rest part of the Sequence except the first element
    
    Specified by:
    
    tail in interface C.Sequence<T>
    
    Returns:
    
    an new reversible sequence contains all elements in this sequence except the first element
    
    See Also:
    
    C.Sequence.head(), tail(int)
  - take
```
C.ReversibleSequence<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
    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:
    
    an new reversible sequence contains the first n elements in this sequence
    
    See Also:
    
    C.Sequence.head(int)
  - takeWhile
```
C.ReversibleSequence<T> takeWhile(Lang.Function<? super T,Boolean> predicate)
```
    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:
    
    an new reversible sequence contains the elements in this sequence until predicate evaluate to false
  - drop
```
C.ReversibleSequence<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
    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 or the -n number of elements to be taken from the tail of this sequence if n is an negative number
    
    Returns:
    
    a reversible sequence without the first n number of elements
  - dropWhile
```
C.ReversibleSequence<T> dropWhile(Lang.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
  - filter
```
C.ReversibleSequence<T> filter(Lang.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.Sequence<T>
    
    Specified by:
    
    filter in interface C.Traversable<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
  - append
```
C.ReversibleSequence<T> append(T t)
```
    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 reversible sequence contains this seq’s element followed by t
  - append
```
C.ReversibleSequence<T> append(C.ReversibleSequence<T> seq)
```
    Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence
    
    Parameters:
    
    seq - another reversible sequence
    
    Returns:
    
    an new reversible sequence contains both seq’s elements
  - prepend
```
C.ReversibleSequence<T> prepend(T t)
```
    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:
    
    a reversible sequence contains by t followed this seq’s element
  - prepend
```
C.ReversibleSequence<T> prepend(C.ReversibleSequence<T> seq)
```
    Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence
    
    Parameters:
    
    seq - another reversible sequence
    
    Returns:
    
    an new reversible sequence contains both seq’s elements
  - last
```
T last()
throws UnsupportedOperationException,
       NoSuchElementException
```
    Returns the last element from this Sequence
    
    Returns:
    
    the last element
    
    Throws:
    
    UnsupportedOperationException - if this Sequence is not limited
    
    NoSuchElementException - if the Sequence is empty
    
    Since:
    
    0.2
    
    See Also:
    
    C.Traversable.isEmpty(), C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - tail
```
C.ReversibleSequence<T> tail(int n)
                      throws UnsupportedOperationException,
                             IndexOutOfBoundsException
```
    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
    Parameters:
    
    n - specify the number of elements to be taken from the tail of this Sequence
    
    Returns:
    
    a Sequence consisting of the last n elements from this Sequence
    
    Throws:
    
    UnsupportedOperationException - if the traversal is unlimited or empty
    
    IndexOutOfBoundsException - if n is greater than the size of this Sequence
    
    Since:
    
    0.2
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - reverse
```
C.ReversibleSequence<T> reverse()
                         throws UnsupportedOperationException
```
    Returns an new Sequence that reverse this Sequence.
    
    Returns:
    
    a reversed Sequence
    
    Throws:
    
    UnsupportedOperationException - if this Sequence is unlimited
    
    Since:
    
    0.2
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - reverseIterator
```
Iterator<T> reverseIterator()
```
    Returns an Iterator iterate the sequence from tail to head
    
    Returns:
    
    the iterator
    
    Since:
    
    0.2
  - reduceRight
```
<R> R reduceRight(R identity,
                  Lang.Func2<R,T,R> accumulator)
```
    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; 
```
    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
    
    Since:
    
    0.2
    
    See Also:
    
    #reduce(Object, Func2)
  - reduceRight
```
Lang.Option<T> reduceRight(Lang.Func2<T,T,T> accumulator)
```
    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); 
```
    Parameters:
    
    accumulator - the function accumulate each element to the final result
    
    Returns:
    
    an Lang.Option describing the accumulating result
    
    Since:
    
    0.2
  - findLast
```
Lang.Option<T> findLast(Lang.Function<? super T,Boolean> predicate)
```
    Apply the predicate specified to the element of this sequence from tail to head. Stop at the element that returns true, and returns an Lang.Option describing the element. If none of the element applications in the sequence returns true then Lang.none() is returned
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Lang.none()
    
    Since:
    
    0.2
  - map
```
<R> C.ReversibleSequence<R> map(Lang.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.Sequence<T>
    
    Specified by:
    
    map in interface C.Traversable<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
```
<R> C.ReversibleSequence<R> flatMap(Lang.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. 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>
    
    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 ReversibleSequence of R type element that are mapped from this sequences
    
    Since:
    
    0.2
  - accept
```
C.ReversibleSequence<T> accept(Lang.Visitor<? 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>
    
    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
```
C.ReversibleSequence<T> each(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Lang.Visitor)
    
    Specified by:
    
    each in interface C.Sequence<T>
    
    Specified by:
    
    each in interface C.Traversable<T>
    
    Parameters:
    
    visitor - the visitor to tranverse the elements
    
    Returns:
    
    this Traversable instance
  - forEach
```
C.ReversibleSequence<T> forEach(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Lang.Visitor)
    
    Specified by:
    
    forEach in interface C.Sequence<T>
    
    Specified by:
    
    forEach in interface C.Traversable<T>
    
    Parameters:
    
    visitor - the visitor function
    
    Returns:
    
    this Traversable instance
  - acceptLeft
```
C.ReversibleSequence<T> acceptLeft(Lang.Visitor<? 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(Lang.Visitor), acceptRight(Lang.Visitor)
  - acceptRight
```
C.ReversibleSequence<T> acceptRight(Lang.Visitor<? super T> visitor)
```
    Iterate through this sequence from tail to head with the visitor function specified
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    Since:
    
    0.2
    
    See Also:
    
    C.Traversable.accept(Lang.Visitor), C.Sequence.acceptLeft(Lang.Visitor)
  - zip
```
<T2> C.ReversibleSequence<Lang.Binary<T,T2>> zip(C.ReversibleSequence<T2> rseq)
```
  - zipAll
```
<T2> C.ReversibleSequence<Lang.Binary<T,T2>> zipAll(C.ReversibleSequence<T2> rseq,
                                                    T def1,
                                                    T2 def2)
```

Interface C.ReversibleSequence<T>

Nested Class Summary

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

Method Summary

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

Method Detail

parallel

sequential

lazy

eager

head

tail

take

takeWhile

drop

dropWhile

filter

append

append

prepend

prepend

last

tail

reverse

reverseIterator

reduceRight

reduceRight

findLast

map

flatMap

accept

each

forEach

acceptLeft

acceptRight

zip

zipAll