RubyArray

java.lang.Object
- net.sf.rubycollect4j.RubyEnumerable<E>
- - net.sf.rubycollect4j.RubyArray<E>

Type Parameters:
E - the type of the elements

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<java.util.List<E>>, java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>, Ruby.Enumerable<E>, RubyContract.Enumerable<E,Ruby.Enumerator<?>,RubyArray<?>>
```
public final class RubyArray<E>
extends RubyEnumerable<E>
implements java.util.List<E>, java.lang.Comparable<java.util.List<E>>, java.io.Serializable
```
RubyArray implements all methods refer to the Array class of Ruby language.
RubyArray is also a Java List and a Ruby.Enumerable.

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`RubyArray()` Creates a `RubyArray`.
`RubyArray(java.lang.Iterable<? extends E> iter)` Creates a `RubyArray` by given Iterable.
`RubyArray(java.util.List<E> list)` Creates a `RubyArray` by given List.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)`
`void`	`add(int index, E element)`
`boolean`	`addAll(java.util.Collection<? extends E> c)`
`boolean`	`addAll(int index, java.util.Collection<? extends E> c)`
`<S> RubyArray<S>`	`assoc(S target)` Finds a List element which contains the target as the first element.
`E`	`at(int index)` Returns the element at any index.
`E`	`bsearch(E target)` Uses binary search to find an element.
`E`	`bsearch(E target, java.util.Comparator<? super E> comp)` Uses binary search with a Comparator to Finds an element.
`E`	`bsearch(TransformBlock<? super E,java.lang.Integer> block)` Uses binary search and a block to find an element.
`void`	`clear()`
`RubyArray<E>`	`collectǃ(java.lang.String methodName, java.lang.Object... args)` Transforms each element by given method name in self.
`RubyArray<E>`	`collectǃ(TransformBlock<? super E,? extends E> block)` Transforms each element in self.
`RubyEnumerator<RubyArray<E>>`	`combination(int n)` Generates all combinations with length n of this `RubyArray`.
`RubyArray<E>`	`combination(int n, Block<? super RubyArray<E>> block)` Generates all combinations of length n with elements of this `RubyArray` and yields them with a block.
`RubyArray<E>`	`compact()` Removes all null elements and puts the rest into a new `RubyArray`.
`RubyArray<E>`	`compactǃ()` Removes all null elements in this `RubyArray`.
`int`	`compareTo(java.util.List<E> arg0)`
`RubyArray<E>`	`concat(java.util.Collection<? extends E> other)` Appends all elements of other Collection in this `RubyArray`.
`boolean`	`contains(java.lang.Object o)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`static <E> RubyArray<E>`	`copyOf(java.lang.Iterable<E> elements)` Returns a `RubyArray` which copies the elements of given Iterable.
`int`	`count(E target)` Returns a total number of the target element in this `RubyArray`.
`E`	`delete(E target)` Deletes all elements which equal to the target.
`E`	`delete(E target, TransformBlock<? super E,? extends E> block)` Deletes all elements which equals to target.
`E`	`deleteAt(int index)` Deletes the element of any index.
`RubyEnumerator<E>`	`deleteIf()` Returns a `RubyEnumerator` of this `RubyArray`.
`RubyArray<E>`	`deleteIf(BooleanBlock<? super E> block)` Deletes elements which are true returned by the block.
`RubyArray<E>`	`each(Block<? super E> block)` Yields each element to the block.
`RubyEnumerator<java.lang.Integer>`	`eachIndex()` Returns a `RubyEnumerator` of this `RubyArray`.
`RubyArray<E>`	`eachIndex(Block<java.lang.Integer> block)` Yields each index of elements to the block.
`boolean`	`emptyʔ()` Checks if this is an empty `RubyArray`.
`boolean`	`eqlʔ(java.lang.Object o)` Equivalent to `equals(Object)`.
`boolean`	`equals(java.lang.Object o)`
`E`	`fetch(int index)` Returns the element at an index.
`E`	`fetch(int index, Block<java.lang.Integer> block)` Returns the element at an index.
`E`	`fetch(int index, E defaultValue)` Returns the element at an index.
`RubyArray<E>`	`fill(E item)` Fills the whole `RubyArray` with the element.
`RubyArray<E>`	`fill(E item, int start)` Starts to fill this `RubyArray` from an index with the element.
`RubyArray<E>`	`fill(E item, int start, int length)` Starts to fill part of this `RubyArray` from an index with the element.
`RubyArray<E>`	`fill(int start, int length, TransformBlock<java.lang.Integer,? extends E> block)` Starts to fill part of this `RubyArray` from an index with elements returned by the block.
`RubyArray<E>`	`fill(int start, TransformBlock<java.lang.Integer,? extends E> block)` Starts to fill this `RubyArray` from an index with elements returned by the block.
`RubyArray<E>`	`fill(TransformBlock<java.lang.Integer,? extends E> block)` Fills the whole `RubyArray` with elements returned by the block.
`<S> RubyArray<S>`	`flatten()` Flattens this `RubyArray` of Lists to 1 dimensional `RubyArray` .
`<S> RubyArray<S>`	`flatten(int n)` Flattens this `RubyArray` of Lists to (current - n) dimensional `RubyArray`.
`RubyArray<E>`	`freeze()` Freezes this `RubyArray`.
`boolean`	`frozenʔ()` Checks if this `RubyArray` is frozen.
`E`	`get(int index)`
`protected java.lang.Iterable<E>`	`getIterable()` Returns an Iterable of elements.
`int`	`hash()` Equivalent to `hashCode()`.
`int`	`hashCode()`
`java.lang.Integer`	`index(BooleanBlock<? super E> block)` Finds the first index of an element which gets true returned by the block.
`java.lang.Integer`	`index(E target)` Finds the index of an element.
`int`	`indexOf(java.lang.Object o)`
`RubyArray<E>`	`insert(int index, E... args)` Starts to insert elements to this `RubyArray` from given index.
`java.lang.String`	`inspect()` Equivalent to `toString()`.
`RubyArray<E>`	`intersection(java.util.Collection<? extends E> other)` Puts all common elements into a new `RubyArray`.
`boolean`	`isEmpty()`
`java.util.Iterator<E>`	`iterator()`
`java.lang.String`	`join()` Transforms each element to a String, then joins them.
`java.lang.String`	`join(java.lang.String separator)` Transforms each element to a String, then joins them by given separator.
`RubyEnumerator<E>`	`keepIf()` Returns a `RubyEnumerator` of this `RubyArray`.
`RubyArray<E>`	`keepIf(BooleanBlock<? super E> block)` Keeps elements which are true returned by the block.
`E`	`last()` Returns the last element of this `RubyArray`.
`RubyArray<E>`	`last(int n)` Returns last n elements of this `RubyArray`.
`int`	`lastIndexOf(java.lang.Object o)`
`int`	`length()` Equivalent to `size()`.
`java.util.ListIterator<E>`	`listIterator()`
`java.util.ListIterator<E>`	`listIterator(int index)`
`RubyArray<E>`	`mapǃ(java.lang.String methodName, java.lang.Object... args)` Equivalent to `collectǃ(String, Object...)`.
`RubyArray<E>`	`mapǃ(TransformBlock<? super E,? extends E> block)` Equivalent to `collectǃ(TransformBlock)`.
`RubyArray<E>`	`minus(java.util.Collection<? extends E> other)` Eliminates all elements from other Collection and puts the result into a new `RubyArray`.
`RubyArray<E>`	`multiply(int n)` Multiplies this `RubyArray` by n times.
`java.lang.String`	`multiply(java.lang.String separator)` Equivalent to `join(String)`.
`static <E> RubyArray<E>`	`of(java.util.List<E> list)` Returns a `RubyArray` which wraps the given List.
`java.lang.String`	`pack(java.lang.String aTemplateString)` Packs the contents of this `RubyArray` into a binary string according to the directives in aTemplateString.
`RubyEnumerator<RubyArray<E>>`	`permutation()` Generates a `RubyEnumerator` which contains all permutations of this `RubyArray`.
`RubyArray<E>`	`permutation(Block<? super RubyArray<E>> block)` Yields all permutations of this `RubyArray` to the block.
`RubyEnumerator<RubyArray<E>>`	`permutation(int n)` Generates a `RubyEnumerator` which contains all permutations with length n of this `RubyArray`.
`RubyArray<E>`	`permutation(int n, Block<? super RubyArray<E>> block)` Yields all permutations with length n of this `RubyArray` to the block.
`RubyArray<E>`	`plus(java.util.Collection<? extends E> other)` Appends other Collection to self and puts the result into a new `RubyArray`.
`E`	`pop()` Removes and returns the last element of this `RubyArray`.
`RubyArray<E>`	`pop(int n)` Removes and returns the last n element of this `RubyArray`.
`RubyArray<RubyArray<E>>`	`product(java.util.List<? extends E>... others)` Generates the production of self with other Lists.
`RubyArray<RubyArray<E>>`	`product(java.util.List<? extends java.util.List<? extends E>> others)` Generates the production of self with a List of Lists.
`RubyArray<E>`	`product(java.util.List<? extends java.util.List<? extends E>> others, Block<RubyArray<E>> block)` Generates the productions of self with a List of Lists and yield them to the block.
`RubyArray<E>`	`push(E... items)` Adds items to the end of this `RubyArray`.
`RubyArray<E>`	`push(E item)` Adds the item to the end of this `RubyArray`.
`<S> RubyArray<S>`	`rassoc(S target)` Finds a List element which contains target as the last element.
`RubyEnumerator<E>`	`rejectǃ()` Returns a `RubyEnumerator` of this `RubyArray`.
`RubyArray<E>`	`rejectǃ(BooleanBlock<? super E> block)` Deletes all elements which are false returned by the block.
`E`	`remove(int index)`
`boolean`	`remove(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> c)`
`RubyEnumerator<RubyArray<E>>`	`repeatedCombination(int n)` Generates all repeated combinations of this `RubyArray`.
`RubyArray<E>`	`repeatedCombination(int n, Block<? super RubyArray<E>> block)` Generates all repeated combinations with length n of this `RubyArray` and yield to the block.
`RubyEnumerator<RubyArray<E>>`	`repeatedPermutation(int n)` Generates all repeated permutations with length n of this `RubyArray` .
`RubyArray<E>`	`repeatedPermutation(int n, Block<? super RubyArray<E>> block)` Generates all repeated permutations with length n of this `RubyArray` and yield to the block.
`RubyArray<E>`	`replace(java.util.Collection<? extends E> other)` Replaces all elements of self with other List.
`boolean`	`retainAll(java.util.Collection<?> c)`
`RubyArray<E>`	`reverse()` Reverses this `RubyArray` and puts the result into a new `RubyArray`.
`RubyArray<E>`	`reverseǃ()` Reverses this `RubyArray`.
`RubyEnumerator<E>`	`rindex()` Returns a `RubyEnumerator` of this `RubyArray` reversed.
`java.lang.Integer`	`rindex(BooleanBlock<? super E> block)` Finds the last index of the element which gets true returned by the block.
`java.lang.Integer`	`rindex(E target)` Finds the last index of the target element.
`RubyArray<E>`	`rotate()` Moves the first element to the last and puts them into a new `RubyArray`.
`RubyArray<E>`	`rotate(int n)` Moves the first element to the last n times and puts them into a new RubyArray.
`RubyArray<E>`	`rotateǃ()` Moves the first element to the last.
`RubyArray<E>`	`rotateǃ(int n)` Moves the first element to the last n times.
`E`	`sample()` Picks an element randomly.
`RubyArray<E>`	`sample(int n)` Picks n element randomly.
`RubyEnumerator<E>`	`selectǃ()` Returns a `RubyEnumerator` of this `RubyArray`.
`RubyArray<E>`	`selectǃ(BooleanBlock<? super E> block)` Selects elements which the result returned by the block are false.
`E`	`set(int index, E element)`
`E`	`shift()` Removes and returns the first element.
`RubyArray<E>`	`shift(int n)` Removes and returns the first n element.
`RubyArray<E>`	`shuffle()` Shuffles this `RubyArray` and puts the result into a new `RubyArray`.
`RubyArray<E>`	`shuffleǃ()` Shuffles this `RubyArray`.
`int`	`size()`
`E`	`slice(int index)` Equivalent to `at(int)`.
`RubyArray<E>`	`slice(int index, int length)` Slices an interval of this `RubyArray` into a new `RubyArray`.
`E`	`sliceǃ(int index)` Removes and returns an element of given index out of this `RubyArray` .
`RubyArray<E>`	`sliceǃ(int index, int length)` Slices an interval of this `RubyArray` out of self.
`RubyEnumerator<E>`	`sortByǃ()` Return a `RubyEnumerator` of this `RubyArray`.
`<S> RubyArray<E>`	`sortByǃ(java.util.Comparator<? super E> comp1, java.util.Comparator<? super S> comp2, TransformBlock<? super E,? extends S> block)` Sorts elements of this `RubyArray` by the ordering of outputs transformed by the block induced by the Comparator for S and applies the Comparator for E again.
`<S> RubyArray<E>`	`sortByǃ(java.util.Comparator<? super S> comp, TransformBlock<? super E,? extends S> block)` Sorts elements of this `RubyArray` by the ordering of outputs transformed by the block induced by the Comparator.
`<S> RubyArray<E>`	`sortByǃ(java.lang.String methodName, java.lang.Object... args)` Sorts elements of this `RubyArray` by the ordering of outputs invoked by given method name.
`<S> RubyArray<E>`	`sortByǃ(TransformBlock<? super E,? extends S> block)` Sorts elements of this `RubyArray` by the ordering of putputs transformed by the block.
`RubyArray<E>`	`sortǃ()` Sorts this `RubyArray`.
`RubyArray<E>`	`sortǃ(java.util.Comparator<? super E> comp)` Sorts this `RubyArray` by given Comparator.
`java.util.List<E>`	`subList(int fromIndex, int toIndex)`
`java.lang.Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`java.lang.String`	`toS()` Equivalent to `toString()`.
`java.lang.String`	`toString()`
`<S> RubyArray<RubyArray<S>>`	`transpose()` Assumes this `RubyArray` is a matrix and transpose this matrix into a new `RubyArray`.
`RubyArray<E>`	`union(java.util.Collection<? extends E> other)` Puts all distinct elements into a new `RubyArray`.
`RubyArray<E>`	`uniq()` Filters elements uniquely and puts the result into a new `RubyArray`.
`<S> RubyArray<E>`	`uniq(java.lang.String methodName, java.lang.Object... args)` Filters elements by the result invoked by given method name uniquely and puts the result into a new `RubyArray`.
`<S> RubyArray<E>`	`uniq(TransformBlock<? super E,? extends S> block)` Filters elements by the result returned by the block uniquely and puts the result into a new `RubyArray`.
`RubyArray<E>`	`uniqǃ()` Filters elements uniquely.
`<S> RubyArray<E>`	`uniqǃ(java.lang.String methodName, java.lang.Object... args)` Filters elements by the result invoked by given method name uniquely and puts the result into a new `RubyArray`.
`<S> RubyArray<E>`	`uniqǃ(TransformBlock<? super E,? extends S> block)` Filters elements by the result returned by the block uniquely.
`RubyArray<E>`	`unshift(E item)` Puts an element at beginning of this `RubyArray`
`RubyArray<E>`	`valuesAt(int... indices)` Puts all elements from given indices into a new `RubyArray`.
`RubyArray<E>`	`valuesAt(java.lang.Iterable<java.lang.Integer> indices)` Puts all elements from given indices into a new `RubyArray`.

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable
allʔ, allʔ, anyʔ, anyʔ, chunk, chunk, collect, collect, collect, collectConcat, collectConcat, count, count, cycle, cycle, cycle, cycle, detect, detect, drop, dropWhile, dropWhile, each, eachCons, eachCons, eachEntry, eachEntry, eachSlice, eachSlice, eachWithIndex, eachWithIndex, eachWithObject, eachWithObject, entries, find, find, findAll, findAll, findIndex, findIndex, findIndex, first, first, flatMap, flatMap, grep, grep, grep, groupBy, groupBy, groupBy, includeʔ, inject, inject, inject, inject, lazy, map, map, map, max, max, maxBy, maxBy, maxBy, maxBy, memberʔ, min, min, minBy, minBy, minBy, minBy, minmax, minmax, minmaxBy, minmaxBy, minmaxBy, minmaxBy, noneʔ, noneʔ, oneʔ, oneʔ, partition, partition, reduce, reduce, reduce, reduce, reject, reject, reverseEach, reverseEach, select, select, sliceBefore, sliceBefore, sort, sortBy, sortBy, sortBy, sortBy, sortBy, take, takeWhile, takeWhile, toA, zip, zip, zip

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

- Constructor Detail
  - RubyArray
```
public RubyArray()
```
    Creates a RubyArray.
  - RubyArray
```
public RubyArray(java.util.List<E> list)
```
    Creates a RubyArray by given List. It's a wrapper implementation. No defensive copy has been made.
    
    Parameters:
    list - a List
    
    Throws:
    
    java.lang.NullPointerException - if list is null
  - RubyArray
```
public RubyArray(java.lang.Iterable<? extends E> iter)
```
    Creates a RubyArray by given Iterable.
    
    Parameters:
    iter - an Iterable
    
    Throws:
    
    java.lang.NullPointerException - if iter is null
- Method Detail
  - of
```
public static <E> RubyArray<E> of(java.util.List<E> list)
```
    Returns a RubyArray which wraps the given List.
    
    Parameters:
    list - any List
    
    Returns:
    RubyArray
    
    Throws:
    
    java.lang.NullPointerException - if list is null
  - copyOf
```
public static <E> RubyArray<E> copyOf(java.lang.Iterable<E> elements)
```
    Returns a RubyArray which copies the elements of given Iterable.
    
    Parameters:
    elements - any Iterable
    
    Returns:
    RubyArray
    
    Throws:
    
    java.lang.NullPointerException - if elements is null
  - getIterable
```
protected java.lang.Iterable<E> getIterable()
```
    Description copied from class: RubyEnumerable
    
    Returns an Iterable of elements.
    
    Specified by:
    
    getIterable in class RubyEnumerable<E>
    
    Returns:
    Iterable
  - assoc
```
public <S> RubyArray<S> assoc(S target)
```
    Finds a List element which contains the target as the first element.
    
    Type Parameters:
    S - the type of a List
    Parameters:
    target - the first element of returned List
    
    Returns:
    List or null
  - at
```
public E at(int index)
```
    Returns the element at any index. -1 represents the last index and so on.
    
    Parameters:
    index - of an element
    
    Returns:
    element or null
  - bsearch
```
public E bsearch(E target)
```
    Uses binary search to find an element. Assumes this RubyArray is already sorted.
    
    Parameters:
    target - to be searched
    
    Returns:
    element or null
  - bsearch
```
public E bsearch(E target,
        java.util.Comparator<? super E> comp)
```
    Uses binary search with a Comparator to Finds an element. Assumes this RubyArray is already sorted.
    
    Parameters:
    target - to be searched
    comp - a Comparator is used to sort this RubyArray
    
    Returns:
    element or null
  - bsearch
```
public E bsearch(TransformBlock<? super E,java.lang.Integer> block)
```
    Uses binary search and a block to find an element. The block needs to compare elements by its own definition and returns an Integer to show the result of comparison (which is much like the result of a Comparator). BinarySearch will be performed based on the comparison result. Assumes this RubyArray is already sorted.
    
    Parameters:
    block - to filter elements
    
    Returns:
    element if target found, null otherwise
  - collectǃ
```
public RubyArray<E> collectǃ(TransformBlock<? super E,? extends E> block)
```
    Transforms each element in self.
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubyArray
  - collectǃ
```
public RubyArray<E> collectǃ(java.lang.String methodName,
                    java.lang.Object... args)
```
    Transforms each element by given method name in self.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubyArray
  - combination
```
public RubyEnumerator<RubyArray<E>> combination(int n)
```
    Generates all combinations with length n of this RubyArray.
    
    Parameters:
    n - length of all combinations
    
    Returns:
    RubyEnumerator
  - combination
```
public RubyArray<E> combination(int n,
                       Block<? super RubyArray<E>> block)
```
    Generates all combinations of length n with elements of this RubyArray and yields them with a block.
    
    Parameters:
    n - length of all combinations
    block - to yield each combination
    
    Returns:
    this RubyArray
  - compact
```
public RubyArray<E> compact()
```
    Removes all null elements and puts the rest into a new RubyArray.
    
    Returns:
    new RubyArray
  - compactǃ
```
public RubyArray<E> compactǃ()
```
    Removes all null elements in this RubyArray. Returns null if nothing is removed.
    
    Returns:
    this RubyArray or null
  - concat
```
public RubyArray<E> concat(java.util.Collection<? extends E> other)
```
    Appends all elements of other Collection in this RubyArray.
    
    Parameters:
    other - a Collection
    
    Returns:
    this RubyArray
  - count
```
public int count(E target)
```
    Returns a total number of the target element in this RubyArray.
    
    Parameters:
    target - to be counted
    
    Returns:
    the total number
  - delete
```
public E delete(E target)
```
    Deletes all elements which equal to the target. Return null if nothing is deleted.
    
    Parameters:
    target - to be deleted
    
    Returns:
    the target or null
  - delete
```
public E delete(E target,
       TransformBlock<? super E,? extends E> block)
```
    Deletes all elements which equals to target. Return the result of the block if nothing is deleted.
    
    Parameters:
    target - to be deleted
    block - to yield if nothing is deleted
    
    Returns:
    element
  - deleteAt
```
public E deleteAt(int index)
```
    Deletes the element of any index. -1 represents the last index. Return null if index is not found.
    
    Parameters:
    index - of an element
    
    Returns:
    element or null
  - deleteIf
```
public RubyEnumerator<E> deleteIf()
```
    Returns a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - deleteIf
```
public RubyArray<E> deleteIf(BooleanBlock<? super E> block)
```
    Deletes elements which are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyArray
  - each
```
public RubyArray<E> each(Block<? super E> block)
```
    Yields each element to the block.
    
    Specified by:
    
    each in interface Ruby.Enumerable<E>
    
    Specified by:
    
    each in interface RubyContract.Enumerable<E,Ruby.Enumerator<?>,RubyArray<?>>
    
    Overrides:
    
    each in class RubyEnumerable<E>
    
    Parameters:
    block - to yield each element
    
    Returns:
    this RubyArray
  - eachIndex
```
public RubyEnumerator<java.lang.Integer> eachIndex()
```
    Returns a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - eachIndex
```
public RubyArray<E> eachIndex(Block<java.lang.Integer> block)
```
    Yields each index of elements to the block.
    
    Parameters:
    block - to yield elements
    
    Returns:
    this RubyArray
  - emptyʔ
```
public boolean emptyʔ()
```
    Checks if this is an empty RubyArray.
    
    Returns:
    true if this RubyArray is empty, false otherwise
  - eqlʔ
```
public boolean eqlʔ(java.lang.Object o)
```
    Equivalent to equals(Object).
    
    Parameters:
    o - an Object
    
    Returns:
    true if 2 objects are equal, false otherwise
  - fetch
```
public E fetch(int index)
```
    Returns the element at an index. -1 represents the last index and so on.
    
    Parameters:
    index - of an element
    
    Returns:
    element
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is not found
  - fetch
```
public E fetch(int index,
      E defaultValue)
```
    Returns the element at an index. -1 represents the last index and so on.
    
    Parameters:
    index - of an element
    defaultValue - the default value while index is not found
    
    Returns:
    element
  - fetch
```
public E fetch(int index,
      Block<java.lang.Integer> block)
```
    Returns the element at an index. -1 represents the last index and so on.
    
    Parameters:
    index - of an element
    block - to yield if index is not found
    
    Returns:
    element or null
  - fill
```
public RubyArray<E> fill(E item)
```
    Fills the whole RubyArray with the element.
    
    Parameters:
    item - to be filled
    
    Returns:
    this RubyArray
  - fill
```
public RubyArray<E> fill(E item,
                int start)
```
    Starts to fill this RubyArray from an index with the element.
    
    Parameters:
    item - to be filled
    start - where to begin
    
    Returns:
    this RubyArray
  - fill
```
public RubyArray<E> fill(E item,
                int start,
                int length)
```
    Starts to fill part of this RubyArray from an index with the element.
    
    Parameters:
    item - to be filled
    start - where to begin
    length - of the interval to be filled
    
    Returns:
    this RubyArray
  - fill
```
public RubyArray<E> fill(TransformBlock<java.lang.Integer,? extends E> block)
```
    Fills the whole RubyArray with elements returned by the block.
    
    Parameters:
    block - to transform elements to be filled
    
    Returns:
    this RubyArray
  - fill
```
public RubyArray<E> fill(int start,
                TransformBlock<java.lang.Integer,? extends E> block)
```
    Starts to fill this RubyArray from an index with elements returned by the block.
    
    Parameters:
    start - where to begin
    block - to transform elements to be filled
    
    Returns:
    this RubyArray
  - fill
```
public RubyArray<E> fill(int start,
                int length,
                TransformBlock<java.lang.Integer,? extends E> block)
```
    Starts to fill part of this RubyArray from an index with elements returned by the block.
    
    Parameters:
    start - where to begin
    length - of the interval to be filled
    block - to transform elements to be filled
    
    Returns:
    this RubyArray
  - flatten
```
public <S> RubyArray<S> flatten()
```
    Flattens this RubyArray of Lists to 1 dimensional RubyArray .
    
    Type Parameters:
    S - the type of elements of the flatten RubyArray
    
    Returns:
    new RubyArray
  - flatten
```
public <S> RubyArray<S> flatten(int n)
```
    Flattens this RubyArray of Lists to (current - n) dimensional RubyArray.
    
    Parameters:
    n - times to flatten
    
    Returns:
    new RubyArray
  - freeze
```
public RubyArray<E> freeze()
```
    Freezes this RubyArray.
    
    Returns:
    this RubyArray
  - frozenʔ
```
public boolean frozenʔ()
```
    Checks if this RubyArray is frozen.
    
    Returns:
    true if this RubyArray is frozen, false otherwise
  - hash
```
public int hash()
```
    Equivalent to hashCode().
    
    Returns:
    the hash code
  - index
```
public java.lang.Integer index(BooleanBlock<? super E> block)
```
    Finds the first index of an element which gets true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    element or null
  - index
```
public java.lang.Integer index(E target)
```
    Finds the index of an element.
    
    Parameters:
    target - to be found
    
    Returns:
    element or null
  - insert
```
public RubyArray<E> insert(int index,
                  E... args)
```
    Starts to insert elements to this RubyArray from given index.
    
    Parameters:
    index - where to begin
    args - elements to be inserted
    
    Returns:
    this RubyArray
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is less than -size
  - inspect
```
public java.lang.String inspect()
```
    Equivalent to toString().
    
    Returns:
    String
  - intersection
```
public RubyArray<E> intersection(java.util.Collection<? extends E> other)
```
    Puts all common elements into a new RubyArray.
    
    Parameters:
    other - a Collection
    
    Returns:
    new RubyArray
  - join
```
public java.lang.String join()
```
    Transforms each element to a String, then joins them.
    
    Returns:
    String
  - join
```
public java.lang.String join(java.lang.String separator)
```
    Transforms each element to a String, then joins them by given separator.
    
    Parameters:
    separator - used to join elements
    
    Returns:
    String
  - keepIf
```
public RubyEnumerator<E> keepIf()
```
    Returns a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - keepIf
```
public RubyArray<E> keepIf(BooleanBlock<? super E> block)
```
    Keeps elements which are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyArray
  - last
```
public E last()
```
    Returns the last element of this RubyArray. Returns null if this RubyArray is empty.
    
    Returns:
    element or null
  - last
```
public RubyArray<E> last(int n)
```
    Returns last n elements of this RubyArray.
    
    Parameters:
    n - number of elements
    
    Returns:
    new RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - length
```
public int length()
```
    Equivalent to size().
    
    Returns:
    size of this RubyArray
  - mapǃ
```
public RubyArray<E> mapǃ(TransformBlock<? super E,? extends E> block)
```
    Equivalent to collectǃ(TransformBlock).
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubyArray
  - mapǃ
```
public RubyArray<E> mapǃ(java.lang.String methodName,
                java.lang.Object... args)
```
    Equivalent to collectǃ(String, Object...).
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubyArray
  - multiply
```
public RubyArray<E> multiply(int n)
```
    Multiplies this RubyArray by n times.
    
    Parameters:
    n - multiply n times
    
    Returns:
    new RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - multiply
```
public java.lang.String multiply(java.lang.String separator)
```
    Equivalent to join(String).
    
    Parameters:
    separator - used to join elements
    
    Returns:
    String
  - pack
```
public java.lang.String pack(java.lang.String aTemplateString)
```
    Packs the contents of this RubyArray into a binary string according to the directives in aTemplateString.
    
    Parameters:
    aTemplateString - a template string
    
    Returns:
    binary string
    See Also:
    Directive
  - permutation
```
public RubyEnumerator<RubyArray<E>> permutation()
```
    Generates a RubyEnumerator which contains all permutations of this RubyArray.
    
    Returns:
    RubyEnumerator
  - permutation
```
public RubyEnumerator<RubyArray<E>> permutation(int n)
```
    Generates a RubyEnumerator which contains all permutations with length n of this RubyArray.
    
    Parameters:
    n - length of each permutation
    
    Returns:
    RubyEnumerator
  - permutation
```
public RubyArray<E> permutation(int n,
                       Block<? super RubyArray<E>> block)
```
    Yields all permutations with length n of this RubyArray to the block.
    
    Parameters:
    n - length of each permutation
    block - to yield each permutation
    
    Returns:
    this RubyArray
  - permutation
```
public RubyArray<E> permutation(Block<? super RubyArray<E>> block)
```
    Yields all permutations of this RubyArray to the block.
    
    Parameters:
    block - to yield each permutation
    
    Returns:
    this RubyArray
  - plus
```
public RubyArray<E> plus(java.util.Collection<? extends E> other)
```
    Appends other Collection to self and puts the result into a new RubyArray.
    
    Parameters:
    other - a Collection
    
    Returns:
    new RubyArray
  - pop
```
public E pop()
```
    Removes and returns the last element of this RubyArray.
    
    Returns:
    element or null
  - pop
```
public RubyArray<E> pop(int n)
```
    Removes and returns the last n element of this RubyArray.
    
    Parameters:
    n - number of elements
    
    Returns:
    new RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - product
```
public RubyArray<RubyArray<E>> product(java.util.List<? extends E>... others)
```
    Generates the production of self with other Lists.
    
    Parameters:
    others - Lists
    
    Returns:
    new RubyArray of RubyArrays
  - product
```
public RubyArray<RubyArray<E>> product(java.util.List<? extends java.util.List<? extends E>> others)
```
    Generates the production of self with a List of Lists.
    
    Parameters:
    others - a List of Lists
    
    Returns:
    new RubyArray of RubyArrays
  - product
```
public RubyArray<E> product(java.util.List<? extends java.util.List<? extends E>> others,
                   Block<RubyArray<E>> block)
```
    Generates the productions of self with a List of Lists and yield them to the block.
    
    Parameters:
    others - a List of Lists
    block - to yield each production
    
    Returns:
    this RubyArray
  - push
```
public RubyArray<E> push(E item)
```
    Adds the item to the end of this RubyArray.
    
    Parameters:
    item - an element
    
    Returns:
    this RubyArray
  - push
```
public RubyArray<E> push(E... items)
```
    Adds items to the end of this RubyArray.
    
    Parameters:
    items - an array of element
    
    Returns:
    this RubyArray
  - rassoc
```
public <S> RubyArray<S> rassoc(S target)
```
    Finds a List element which contains target as the last element.
    
    Type Parameters:
    S - the type of a List
    Parameters:
    target - the last element of returned List
    
    Returns:
    List or null
  - rejectǃ
```
public RubyEnumerator<E> rejectǃ()
```
    Returns a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - rejectǃ
```
public RubyArray<E> rejectǃ(BooleanBlock<? super E> block)
```
    Deletes all elements which are false returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyArray
  - repeatedCombination
```
public RubyEnumerator<RubyArray<E>> repeatedCombination(int n)
```
    Generates all repeated combinations of this RubyArray.
    
    Parameters:
    n - length of each repeated combination
    
    Returns:
    RubyEnumerator
  - repeatedCombination
```
public RubyArray<E> repeatedCombination(int n,
                               Block<? super RubyArray<E>> block)
```
    Generates all repeated combinations with length n of this RubyArray and yield to the block.
    
    Parameters:
    n - length of each repeated combination
    block - to yield each repeated combination
    
    Returns:
    this RubyArray
  - repeatedPermutation
```
public RubyEnumerator<RubyArray<E>> repeatedPermutation(int n)
```
    Generates all repeated permutations with length n of this RubyArray .
    
    Parameters:
    n - length of each repeated permutation
    
    Returns:
    RubyEnumerator
  - repeatedPermutation
```
public RubyArray<E> repeatedPermutation(int n,
                               Block<? super RubyArray<E>> block)
```
    Generates all repeated permutations with length n of this RubyArray and yield to the block.
    
    Parameters:
    n - length of each repeated permutation
    block - to yield each repeated permutation
    
    Returns:
    this RubyArray
  - replace
```
public RubyArray<E> replace(java.util.Collection<? extends E> other)
```
    Replaces all elements of self with other List.
    
    Parameters:
    other - a Collection
    
    Returns:
    this RubyArray
  - reverse
```
public RubyArray<E> reverse()
```
    Reverses this RubyArray and puts the result into a new RubyArray.
    
    Returns:
    new RubyArray
  - reverseǃ
```
public RubyArray<E> reverseǃ()
```
    Reverses this RubyArray.
    
    Returns:
    this RubyArray
  - rindex
```
public RubyEnumerator<E> rindex()
```
    Returns a RubyEnumerator of this RubyArray reversed.
    
    Returns:
    RubyEnumerator
  - rindex
```
public java.lang.Integer rindex(BooleanBlock<? super E> block)
```
    Finds the last index of the element which gets true returned by the block.
    
    Parameters:
    block - to filter the element
    
    Returns:
    element or null
  - rindex
```
public java.lang.Integer rindex(E target)
```
    Finds the last index of the target element.
    
    Parameters:
    target - to be found
    
    Returns:
    element or null
  - rotate
```
public RubyArray<E> rotate()
```
    Moves the first element to the last and puts them into a new RubyArray.
    
    Returns:
    new RubyArray
  - rotateǃ
```
public RubyArray<E> rotateǃ()
```
    Moves the first element to the last.
    
    Returns:
    this RubyArray
  - rotate
```
public RubyArray<E> rotate(int n)
```
    Moves the first element to the last n times and puts them into a new RubyArray.
    
    Parameters:
    n - moves
    
    Returns:
    new RubyArray
  - rotateǃ
```
public RubyArray<E> rotateǃ(int n)
```
    Moves the first element to the last n times.
    
    Parameters:
    n - times to perform the rotations
    
    Returns:
    this RubyArray
  - sample
```
public E sample()
```
    Picks an element randomly.
    
    Returns:
    element
  - sample
```
public RubyArray<E> sample(int n)
```
    Picks n element randomly.
    
    Parameters:
    n - number of elements
    
    Returns:
    new RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - selectǃ
```
public RubyEnumerator<E> selectǃ()
```
    Returns a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - selectǃ
```
public RubyArray<E> selectǃ(BooleanBlock<? super E> block)
```
    Selects elements which the result returned by the block are false. Returns null if nothing is changed.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubyArray or null
  - shift
```
public E shift()
```
    Removes and returns the first element.
    
    Returns:
    element or null
  - shift
```
public RubyArray<E> shift(int n)
```
    Removes and returns the first n element.
    
    Parameters:
    n - number of elements
    
    Returns:
    new RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - shuffle
```
public RubyArray<E> shuffle()
```
    Shuffles this RubyArray and puts the result into a new RubyArray.
    
    Returns:
    new RubyArray
  - shuffleǃ
```
public RubyArray<E> shuffleǃ()
```
    Shuffles this RubyArray.
    
    Returns:
    this RubyArray
  - slice
```
public E slice(int index)
```
    Equivalent to at(int).
    
    Parameters:
    index - of an element
    
    Returns:
    element or null
  - slice
```
public RubyArray<E> slice(int index,
                 int length)
```
    Slices an interval of this RubyArray into a new RubyArray.
    
    Parameters:
    index - where to begin
    length - size of returned RubyArray
    
    Returns:
    new RubyArray
  - sliceǃ
```
public E sliceǃ(int index)
```
    Removes and returns an element of given index out of this RubyArray .
    
    Parameters:
    index - of the element
    
    Returns:
    element
  - sliceǃ
```
public RubyArray<E> sliceǃ(int index,
                  int length)
```
    Slices an interval of this RubyArray out of self.
    
    Parameters:
    index - where to begin
    length - size of returned RubyArray
    
    Returns:
    new RubyArray
  - sortǃ
```
public RubyArray<E> sortǃ()
```
    Sorts this RubyArray.
    
    Returns:
    this RubyArray
  - sortǃ
```
public RubyArray<E> sortǃ(java.util.Comparator<? super E> comp)
```
    Sorts this RubyArray by given Comparator.
    
    Parameters:
    comp - a Comparator
    
    Returns:
    this RubyArray
  - sortByǃ
```
public RubyEnumerator<E> sortByǃ()
```
    Return a RubyEnumerator of this RubyArray.
    
    Returns:
    RubyEnumerator
  - sortByǃ
```
public <S> RubyArray<E> sortByǃ(java.util.Comparator<? super S> comp,
                       TransformBlock<? super E,? extends S> block)
```
    Sorts elements of this RubyArray by the ordering of outputs transformed by the block induced by the Comparator.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    this RubyArray
  - sortByǃ
```
public <S> RubyArray<E> sortByǃ(java.util.Comparator<? super E> comp1,
                       java.util.Comparator<? super S> comp2,
                       TransformBlock<? super E,? extends S> block)
```
    Sorts elements of this RubyArray by the ordering of outputs transformed by the block induced by the Comparator for S and applies the Comparator for E again.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp1 - a Comparator for E
    comp2 - a Comparator for S
    block - to transform elements
    
    Returns:
    this RubyArray
  - sortByǃ
```
public <S> RubyArray<E> sortByǃ(TransformBlock<? super E,? extends S> block)
```
    Sorts elements of this RubyArray by the ordering of putputs transformed by the block.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    this RubyArray
  - sortByǃ
```
public <S> RubyArray<E> sortByǃ(java.lang.String methodName,
                       java.lang.Object... args)
```
    Sorts elements of this RubyArray by the ordering of outputs invoked by given method name.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubyArray
  - minus
```
public RubyArray<E> minus(java.util.Collection<? extends E> other)
```
    Eliminates all elements from other Collection and puts the result into a new RubyArray.
    
    Parameters:
    other - a Collection
    
    Returns:
    new RubyArray
  - toS
```
public java.lang.String toS()
```
    Equivalent to toString().
    
    Returns:
    String
  - transpose
```
public <S> RubyArray<RubyArray<S>> transpose()
```
    Assumes this RubyArray is a matrix and transpose this matrix into a new RubyArray.
    
    Type Parameters:
    S - the type of transformed elements
    
    Returns:
    RubyArray of RubyArrays
    
    Throws:
    
    javax.xml.bind.TypeConstraintException - if S is not a List
    
    java.lang.IndexOutOfBoundsException - if all lists are not the same size
  - union
```
public RubyArray<E> union(java.util.Collection<? extends E> other)
```
    Puts all distinct elements into a new RubyArray.
    
    Parameters:
    other - a Collection
    
    Returns:
    new RubyArray
  - uniq
```
public RubyArray<E> uniq()
```
    Filters elements uniquely and puts the result into a new RubyArray.
    
    Returns:
    new RubyArray
  - uniq
```
public <S> RubyArray<E> uniq(TransformBlock<? super E,? extends S> block)
```
    Filters elements by the result returned by the block uniquely and puts the result into a new RubyArray.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    new RubyArray
  - uniq
```
public <S> RubyArray<E> uniq(java.lang.String methodName,
                    java.lang.Object... args)
```
    Filters elements by the result invoked by given method name uniquely and puts the result into a new RubyArray.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    new RubyArray
  - uniqǃ
```
public RubyArray<E> uniqǃ()
```
    Filters elements uniquely. Returns null if unchanged.
    
    Returns:
    this RubyArray or null
  - uniqǃ
```
public <S> RubyArray<E> uniqǃ(java.lang.String methodName,
                     java.lang.Object... args)
```
    Filters elements by the result invoked by given method name uniquely and puts the result into a new RubyArray.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubyArray or null
  - uniqǃ
```
public <S> RubyArray<E> uniqǃ(TransformBlock<? super E,? extends S> block)
```
    Filters elements by the result returned by the block uniquely.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    this RubyArray
  - unshift
```
public RubyArray<E> unshift(E item)
```
    Puts an element at beginning of this RubyArray
    
    Parameters:
    item - an element
    
    Returns:
    this RubyArray
  - valuesAt
```
public RubyArray<E> valuesAt(int... indices)
```
    Puts all elements from given indices into a new RubyArray.
    
    Parameters:
    indices - where elements to be found
    
    Returns:
    new RubyArray
  - valuesAt
```
public RubyArray<E> valuesAt(java.lang.Iterable<java.lang.Integer> indices)
```
    Puts all elements from given indices into a new RubyArray.
    
    Parameters:
    indices - where elements to be found
    
    Returns:
    new RubyArray
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<E>
    
    Specified by:
    
    size in interface java.util.List<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<E>
    
    Specified by:
    
    isEmpty in interface java.util.List<E>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Specified by:
    
    contains in interface java.util.Collection<E>
    
    Specified by:
    
    contains in interface java.util.List<E>
  - iterator
```
public java.util.Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<E>
    
    Specified by:
    
    iterator in interface java.util.Collection<E>
    
    Specified by:
    
    iterator in interface java.util.List<E>
    
    Overrides:
    
    iterator in class RubyEnumerable<E>
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.List<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.List<E>
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface java.util.Collection<E>
    
    Specified by:
    
    add in interface java.util.List<E>
  - remove
```
public boolean remove(java.lang.Object o)
```
    Specified by:
    
    remove in interface java.util.Collection<E>
    
    Specified by:
    
    remove in interface java.util.List<E>
  - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
    Specified by:
    
    containsAll in interface java.util.Collection<E>
    
    Specified by:
    
    containsAll in interface java.util.List<E>
  - addAll
```
public boolean addAll(java.util.Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface java.util.Collection<E>
    
    Specified by:
    
    addAll in interface java.util.List<E>
  - addAll
```
public boolean addAll(int index,
             java.util.Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface java.util.List<E>
  - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
    Specified by:
    
    removeAll in interface java.util.Collection<E>
    
    Specified by:
    
    removeAll in interface java.util.List<E>
  - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
    Specified by:
    
    retainAll in interface java.util.Collection<E>
    
    Specified by:
    
    retainAll in interface java.util.List<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<E>
    
    Specified by:
    
    clear in interface java.util.List<E>
  - get
```
public E get(int index)
```
    Specified by:
    
    get in interface java.util.List<E>
  - set
```
public E set(int index,
    E element)
```
    Specified by:
    
    set in interface java.util.List<E>
  - add
```
public void add(int index,
       E element)
```
    Specified by:
    
    add in interface java.util.List<E>
  - remove
```
public E remove(int index)
```
    Specified by:
    
    remove in interface java.util.List<E>
  - indexOf
```
public int indexOf(java.lang.Object o)
```
    Specified by:
    
    indexOf in interface java.util.List<E>
  - lastIndexOf
```
public int lastIndexOf(java.lang.Object o)
```
    Specified by:
    
    lastIndexOf in interface java.util.List<E>
  - listIterator
```
public java.util.ListIterator<E> listIterator()
```
    Specified by:
    
    listIterator in interface java.util.List<E>
  - listIterator
```
public java.util.ListIterator<E> listIterator(int index)
```
    Specified by:
    
    listIterator in interface java.util.List<E>
  - subList
```
public java.util.List<E> subList(int fromIndex,
                        int toIndex)
```
    Specified by:
    
    subList in interface java.util.List<E>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Collection<E>
    
    Specified by:
    
    equals in interface java.util.List<E>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Collection<E>
    
    Specified by:
    
    hashCode in interface java.util.List<E>
    
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class RubyEnumerable<E>
  - compareTo
```
public int compareTo(java.util.List<E> arg0)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<java.util.List<E>>

Class RubyArray<E>

Constructor Summary

Method Summary

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable

Methods inherited from class java.lang.Object

Constructor Detail

RubyArray

RubyArray

RubyArray

Method Detail

of

copyOf

getIterable

assoc

at

bsearch

bsearch

bsearch

collectǃ

collectǃ

combination

combination

compact

compactǃ

concat

count

delete

delete

deleteAt

deleteIf

deleteIf

each

eachIndex

eachIndex

emptyʔ

eqlʔ

fetch

fetch

fetch

fill

fill

fill

fill

fill

fill

flatten

flatten

freeze

frozenʔ

hash

index

index

insert

inspect

intersection

join

join

keepIf

keepIf

last

last

length

mapǃ

mapǃ

multiply

multiply

pack

permutation

permutation

permutation

permutation

plus

pop

pop

product

product

product

push

push

rassoc