IList

All Superinterfaces:

ICollection<IList<V>,V>, Iterable<V>

All Known Subinterfaces:

IDiffList<V>, IDiffList.Durable<V>, IList.Durable<V>

All Known Implementing Classes:

ConcatList, DiffList, DurableList, IList.Mixin, LinearList, List
```
public interface IList<V>
extends ICollection<IList<V>,V>, Iterable<V>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface IList.Durable<V>

static class IList.Mixin<V>

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`IList.Durable<V>`
`static class`	`IList.Mixin<V>`

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default IList<V>`	`addFirst(V value)`
`default IList<V>`	`addLast(V value)`
`default IList<V>`	`concat(IList<V> l)`
`default IDiffList<V>`	`diff()`
`default boolean`	`equals(Object o, BiPredicate<V,V> equals)`
`default V`	`first()`
`default IList<V>`	`forked()` This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable.
`default boolean`	`isLinear()`
`default Iterator<V>`	`iterator(long startIndex)`
`default V`	`last()`
`default IList<V>`	`linear()` This returns a data structure which is linear, or temporarily mutable.
`default IList<V>`	`removeFirst()`
`default IList<V>`	`removeLast()`
`default DurableList<V>`	`save(IDurableEncoding encoding, Path directory)`
`default IList<V>`	`set(long idx, V value)`
`default IList<V>`	`slice(long start, long end)`
`default IList<IList<V>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`default Spliterator<V>`	`spliterator()`
`default Stream<V>`	`stream()`
`default Object[]`	`toArray()`
`default V[]`	`toArray(IntFunction<V[]> allocator)`
`default List<V>`	`toList()`
`default IList<V>`	`update(long idx, Function<V,V> updateFn)`

Methods inherited from interface io.lacuna.bifurcan.ICollection
clone, iterator, nth, nth, size

Methods inherited from interface java.lang.Iterable
forEach

- Method Detail
  - update
```
default IList<V> update(long idx,
                        Function<V,V> updateFn)
```
  - isLinear
```
default boolean isLinear()
```
    Specified by:
    
    isLinear in interface ICollection<IList<V>,V>
    
    Returns:
    
    true, if the list is linear
  - addLast
```
default IList<V> addLast(V value)
```
    Returns:
    
    a new list, with value appended
  - addFirst
```
default IList<V> addFirst(V value)
```
    Returns:
    
    a new list, with value prepended
  - removeLast
```
default IList<V> removeLast()
```
    Returns:
    
    a new list with the last value removed, or the same list if already empty
  - removeFirst
```
default IList<V> removeFirst()
```
    Returns:
    
    a new list with the first value removed, or the same value if already empty
  - set
```
default IList<V> set(long idx,
                     V value)
```
    Returns:
    
    a new list, with the element at idx overwritten with value. If idx is equal to ICollection.size(), the value is appended.
    
    Throws:
    
    IndexOutOfBoundsException - when idx is not within [0, size]
  - stream
```
default Stream<V> stream()
```
    Returns:
    
    a Stream, representing the elements in the list
  - spliterator
```
default Spliterator<V> spliterator()
```
    Specified by:
    
    spliterator in interface Iterable<V>
  - iterator
```
default Iterator<V> iterator(long startIndex)
```
    Specified by:
    
    iterator in interface ICollection<IList<V>,V>
  - toArray
```
default Object[] toArray()
```
    Returns:
    
    the elements of the list, in an array
  - toArray
```
default V[] toArray(IntFunction<V[]> allocator)
```
    Parameters:
    
    allocator - a function which creates an array of the specified size
    
    Returns:
    
    the elements of the list, in a typed array
  - toList
```
default List<V> toList()
```
    Returns:
    
    the collection, represented as a normal Java list, which will throw an UnsupportedOperationException for any write
  - split
```
default IList<IList<V>> split(int parts)
```
    Description copied from interface: ICollection
    
    Splits the collection into roughly even pieces, for parallel processing. Depending on the size and contents of the collection, this function may not return exactly parts subsets.
    
    Specified by:
    
    split in interface ICollection<IList<V>,V>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a list containing subsets of the collection.
  - slice
```
default IList<V> slice(long start,
                       long end)
```
    Parameters:
    
    start - the inclusive start of the range
    
    end - the exclusive end of the range
    
    Returns:
    
    a sub-range of the list within [start, end), which is linear if this is linear
  - concat
```
default IList<V> concat(IList<V> l)
```
    Parameters:
    
    l - another list
    
    Returns:
    
    a new collection representing the concatenation of the two lists, which is linear if this is linear
  - first
```
default V first()
```
    Returns:
    
    the first element
    
    Throws:
    
    IndexOutOfBoundsException - if the collection is empty
  - last
```
default V last()
```
    Returns:
    
    the last element
    
    Throws:
    
    IndexOutOfBoundsException - if the collection is empty
  - save
```
default DurableList<V> save(IDurableEncoding encoding,
                            Path directory)
```
    Specified by:
    
    save in interface ICollection<IList<V>,V>
  - diff
```
default IDiffList<V> diff()
```
    Returns:
    
    a diff wrapper around this collection
  - forked
```
default IList<V> forked()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable. This is called "forked" because it means that multiple functions can make divergent changes to the data structure without affecting each other.
    If only a single function or scope uses the data structure, it can be left as a linear data structure, which can have significant performance benefits.
    If the data structure is already forked, it will simply return itself.
    
    Specified by:
    
    forked in interface ICollection<IList<V>,V>
    
    Returns:
    
    a forked form of the data structure
  - linear
```
default IList<V> linear()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is linear, or temporarily mutable. The term "linear", as used here, does not completely align with the formal definition of linear types as used in type theory. It is meant to describe the linear dataflow of the method calls, and as a converse to "forked" data structures.
    If ICollection.forked() is called on a linear collection, all references to that linear collection should be discarded.
    If the data structure is already linear, it will simply return itself.
    
    Specified by:
    
    linear in interface ICollection<IList<V>,V>
    
    Returns:
    
    a linear form of this data structure
  - equals
```
default boolean equals(Object o,
                       BiPredicate<V,V> equals)
```

Interface IList<V>

Nested Class Summary

Method Summary

Methods inherited from interface io.lacuna.bifurcan.ICollection

Methods inherited from interface java.lang.Iterable

Method Detail

update

isLinear

addLast

addFirst

removeLast

removeFirst

set

stream

spliterator

iterator

toArray

toArray

toList

split

slice

concat

first

last

save

diff

forked

linear

equals