Seq (core 4.4.1 API)

java.lang.Object
- fj.data.Seq<A>

All Implemented Interfaces:

java.lang.Iterable<A>
```
public final class Seq<A>
extends java.lang.Object
implements java.lang.Iterable<A>
```
Provides an immutable finite sequence, implemented as a finger tree. This structure gives O(1) access to the head and tail, as well as O(log n) random access and concatenation of sequences.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Seq<A>`	`append(Seq<A> as)` Appends the given sequence to this sequence.
`Seq<A>`	`cons(A a)` Inserts the given element at the front of this sequence.
`Seq<A>`	`drop(int n)` Drops the given number of elements from the head of this sequence if they are available.
`static <A> Seq<A>`	`empty()` The empty sequence.
`boolean`	`equals(java.lang.Object other)`
`<B> B`	`foldLeft(F2<B,A,B> f, B z)`
`<B> B`	`foldRight(F2<A,B,B> f, B z)`
`int`	`hashCode()`
`A`	`head()` The first element of this sequence.
`A`	`index(int i)` Returns the element at the given index.
`Seq<A>`	`init()` The sequence without the last element.
`boolean`	`isEmpty()` Checks if this is the empty sequence.
`boolean`	`isNotEmpty()` Checks if this sequence is not empty.
`java.util.Iterator<A>`	`iterator()` Returns an iterator for this seq.
`A`	`last()` The last element of this sequence.
`int`	`length()` Returns the number of elements in this sequence.
`<B> Seq<B>`	`map(F<A,B> f)`
`static <A> Seq<A>`	`seq(A... as)`
`static <A> Seq<A>`	`seq(List<A> list)`
`static <A> Seq<A>`	`single(A a)` A singleton sequence.
`Seq<A>`	`snoc(A a)` Inserts the given element at the end of this sequence.
`P2<Seq<A>,Seq<A>>`	`split(int i)`
`Seq<A>`	`tail()` The sequence without the first element.
`Seq<A>`	`take(int n)` Takes the given number of elements from the head of this sequence if they are available.
`java.util.List<A>`	`toJavaList()`
`Stream<A>`	`toStream()`
`java.lang.String`	`toString()`
`Seq<A>`	`update(int i, A a)` Replace the element at the given index with the supplied value.

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

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

- Method Detail
  - empty
```
public static <A> Seq<A> empty()
```
    The empty sequence.
    
    Returns:
    
    A sequence with no elements.
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
  - single
```
public static <A> Seq<A> single(A a)
```
    A singleton sequence.
    
    Parameters:
    
    a - The single element in the sequence.
    
    Returns:
    
    A new sequence with the given element in it.
  - seq
```
public static <A> Seq<A> seq(A... as)
```
  - seq
```
public static <A> Seq<A> seq(List<A> list)
```
  - cons
```
public Seq<A> cons(A a)
```
    Inserts the given element at the front of this sequence.
    
    Parameters:
    
    a - An element to insert at the front of this sequence.
    
    Returns:
    
    A new sequence with the given element at the front.
  - snoc
```
public Seq<A> snoc(A a)
```
    Inserts the given element at the end of this sequence.
    
    Parameters:
    
    a - An element to insert at the end of this sequence.
    
    Returns:
    
    A new sequence with the given element at the end.
  - head
```
public A head()
```
    The first element of this sequence. This is an O(1) operation.
    
    Returns:
    
    The first element if this sequence is nonempty, otherwise throws an error.
  - last
```
public A last()
```
    The last element of this sequence. This is an O(1) operation.
    
    Returns:
    
    The last element if this sequence is nonempty, otherwise throws an error.
  - tail
```
public Seq<A> tail()
```
    The sequence without the first element. This is an O(1) operation.
    
    Returns:
    
    The sequence without the first element if this sequence is nonempty, otherwise throws an error.
  - init
```
public Seq<A> init()
```
    The sequence without the last element. This is an O(1) operation.
    
    Returns:
    
    The sequence without the last element if this sequence is nonempty, otherwise throws an error.
  - toStream
```
public Stream<A> toStream()
```
  - toJavaList
```
public final java.util.List<A> toJavaList()
```
  - iterator
```
public final java.util.Iterator<A> iterator()
```
    Returns an iterator for this seq. This method exists to permit the use in a for-each loop.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<A>
    
    Returns:
    
    A iterator for this seq.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - append
```
public Seq<A> append(Seq<A> as)
```
    Appends the given sequence to this sequence.
    
    Parameters:
    
    as - A sequence to append to this one.
    
    Returns:
    
    A new sequence with the given sequence appended to this one.
  - isEmpty
```
public boolean isEmpty()
```
    Checks if this is the empty sequence.
    
    Returns:
    
    True if this sequence is empty, otherwise false.
  - isNotEmpty
```
public boolean isNotEmpty()
```
    Checks if this sequence is not empty.
    
    Returns:
    
    True if this sequence is not empty, otherwise false.
  - length
```
public int length()
```
    Returns the number of elements in this sequence.
    
    Returns:
    
    the number of elements in this sequence.
  - split
```
public P2<Seq<A>,Seq<A>> split(int i)
```
  - index
```
public A index(int i)
```
    Returns the element at the given index. This is an O(log(n)) operation.
    
    Parameters:
    
    i - The index of the element to return.
    
    Returns:
    
    The element at the given index, or throws an error if the index is out of bounds.
  - update
```
public Seq<A> update(int i,
                     A a)
```
    Replace the element at the given index with the supplied value. This is an O(log(n)) operation.
    
    Parameters:
    
    i - The index of the element to update.
    
    a - The new value.
    
    Returns:
    
    The updated sequence, or throws an error if the index is out of bounds.
  - take
```
public Seq<A> take(int n)
```
    Takes the given number of elements from the head of this sequence if they are available.
    
    Parameters:
    
    n - The maximum number of elements to take from this sequence.
    
    Returns:
    
    A sequence consisting only of the first n elements of this sequence, or else the whole sequence, if it has less than n elements.
  - drop
```
public Seq<A> drop(int n)
```
    Drops the given number of elements from the head of this sequence if they are available.
    
    Parameters:
    
    n - The number of elements to drop from this sequence.
    
    Returns:
    
    A sequence consisting of all elements of this sequence except the first n ones, or else the empty sequence, if this sequence has less than n elements.
  - foldLeft
```
public <B> B foldLeft(F2<B,A,B> f,
                      B z)
```
  - foldRight
```
public <B> B foldRight(F2<A,B,B> f,
                       B z)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - map
```
public <B> Seq<B> map(F<A,B> f)
```

Class Seq<A>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

empty

equals

single

seq

seq

cons

snoc

head

last

tail

init

toStream

toJavaList

iterator

toString

append

isEmpty

isNotEmpty

length

split

index

update

take

drop

foldLeft

foldRight

hashCode

map