RubyContract.Enumerable

Type Parameters:
E - the type of the elements
N - the type of what kind of RubyContract.Enumerator should be used
Z - the type to define if some methods are lazy or eager loading

All Superinterfaces:

java.lang.Iterable<E>

All Known Subinterfaces:

Ruby.Enumerable<E>, Ruby.Enumerator<E>, Ruby.LazyEnumerator<E>, RubyContract.Enumerator<E,N,Z>

All Known Implementing Classes:

RubyArray, RubyDir, RubyEnumerable, RubyEnumerator, RubyHash, RubyLazyEnumerator, RubyRange, RubySet, RubyString

Enclosing class:

RubyContract
```
static interface RubyContract.Enumerable<E,N extends RubyContract.Enumerator<?,?,?>,Z extends RubyContract.Enumerable<?,?,?>>
extends java.lang.Iterable<E>
```
RubyContract.Enumerable defines all methods of a Ruby Enumerable should have.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`allʔ()` Checks if null is excluded.
`boolean`	`allʔ(BooleanBlock<? super E> block)` Checks if any result returned by the block is false.
`boolean`	`anyʔ()` Checks if any non-null object is included.
`boolean`	`anyʔ(BooleanBlock<? super E> block)` Checks if any result returned by the block is true.
`<S> N`	`chunk(java.lang.String methodName, java.lang.Object... args)` Chunks elements into entries.
`<S> N`	`chunk(TransformBlock<? super E,? extends S> block)` Chunks elements into entries.
`N`	`collect()` Returns an enumerator of elements.
`<S> Z`	`collect(java.lang.String methodName, java.lang.Object... args)` Transforms each element by given method.
`<S> Z`	`collect(TransformBlock<? super E,? extends S> block)` Transforms each element by the block.
`N`	`collectConcat()` Returns an enumerator of elements.
`<S> Z`	`collectConcat(TransformBlock<? super E,? extends java.util.List<? extends S>> block)` Turns each element into a List and then flattens it.
`int`	`count()` Counts the elements.
`int`	`count(BooleanBlock<? super E> block)` Counts the elements which are true returned by the block.
`N`	`cycle()` Generates a sequence from first element to last element and so on infinitely.
`void`	`cycle(Block<? super E> block)` Generates a sequence from start element to end element and so on infinitely.
`N`	`cycle(int n)` Generates a sequence from first element to last element, repeat n times.
`void`	`cycle(int n, Block<? super E> block)` Generates a sequence from start element to end element, repeat n times.
`N`	`detect()` Returns an enumerator of elements.
`E`	`detect(BooleanBlock<? super E> block)` Finds the first element which gets true returned by the block.
`Z`	`drop(int n)` Drops the first n elements.
`N`	`dropWhile()` Returns an enumerator which contains only the first element.
`Z`	`dropWhile(BooleanBlock<? super E> block)` Drops the first n elements until an element gets false returned by the block.
`N`	`each()` Returns an enumerator of elements.
`RubyContract.Enumerable<E,N,Z>`	`each(Block<? super E> block)` Yields each element to the block.
`N`	`eachCons(int n)` Iterates each element and puts the element with n - 1 consecutive elements into a `RubyArray`.
`void`	`eachCons(int n, Block<? super RubyArray<E>> block)` Iterates each element and yields the element with n - 1 consecutive elements to the block.
`N`	`eachEntry()` Returns an enumerator of elements.
`RubyContract.Enumerable<E,N,Z>`	`eachEntry(Block<? super E> block)` Yields each element to the block.
`N`	`eachSlice(int n)` Slices elements into `RubyArray`s with length n.
`void`	`eachSlice(int n, Block<? super RubyArray<E>> block)` Slices elements into `RubyArray`s with length n and yield them to the block.
`N`	`eachWithIndex()` Iterates elements with their indices by Entry.
`RubyContract.Enumerable<E,N,Z>`	`eachWithIndex(WithIndexBlock<? super E> block)` Iterates elements with their indices and yields them to the block.
`<O> N`	`eachWithObject(O obj)` Iterates elements with an object O.
`<O> O`	`eachWithObject(O obj, WithObjectBlock<? super E,? super O> block)` Iterates elements with an object O and yield them to the block.
`RubyArray<E>`	`entries()` Puts each element into a `RubyArray`.
`N`	`find()` Equivalent to `detect()`.
`E`	`find(BooleanBlock<? super E> block)` Equivalent to `detect(BooleanBlock)`.
`N`	`findAll()` Returns an enumerator of elements.
`Z`	`findAll(BooleanBlock<? super E> block)` Finds all elements which are true returned by the block.
`N`	`findIndex()` Returns an enumerator of elements.
`java.lang.Integer`	`findIndex(BooleanBlock<? super E> block)` Returns the index of first element which gets true returned by the block.
`java.lang.Integer`	`findIndex(E target)` Returns the index of the target element.
`E`	`first()` Returns first element.
`RubyArray<E>`	`first(int n)` Returns the first n elements.
`N`	`flatMap()` Equivalent to `collectConcat()`.
`<S> Z`	`flatMap(TransformBlock<? super E,? extends java.util.List<? extends S>> block)` Equivalent to `collectConcat(TransformBlock)`.
`Z`	`grep(java.lang.String regex)` Finds all elements which are matched by the regular expression.
`<S> Z`	`grep(java.lang.String regex, java.lang.String methodName, java.lang.Object... args)` Finds all elements which are matched by the regular expression and invokes them by given method name.
`<S> Z`	`grep(java.lang.String regex, TransformBlock<? super E,? extends S> block)` Finds all elements which are matched by the regular expression and transforms them.
`N`	`groupBy()` Returns an enumerator of elements.
`<S> RubyHash<S,RubyArray<E>>`	`groupBy(java.lang.String methodName, java.lang.Object... args)` Puts elements with the same result S invoked by given method name into a Entry<S, RubyArray<E>>y of a `RubyHash`.
`<S> RubyHash<S,RubyArray<E>>`	`groupBy(TransformBlock<? super E,? extends S> block)` Puts elements with the same result S returned by the block into a Entry<S, RubyArray<E>>y of a `RubyHash`.
`boolean`	`includeʔ(E target)` Checks if target element is included.
`<I> I`	`inject(I init, java.lang.String methodName)` Reduces each element with initial value by a method of S, then assigns the result back to initial value and so on.
`<I> I`	`inject(I init, WithInitBlock<? super E,I> block)` Reduces each element with block, then assigns the result back to initial value and so on.
`E`	`inject(ReduceBlock<E> block)` Assigns the first element as the initial value.
`E`	`inject(java.lang.String methodName)` Assigns the first element as the initial value.
`RubyLazyEnumerator<E>`	`lazy()` Returns a `RubyLazyEnumerator`.
`N`	`map()` Returns an enumerator of elements.
`<S> Z`	`map(java.lang.String methodName, java.lang.Object... args)` Equivalent to `collect(String, Object...)`.
`<S> Z`	`map(TransformBlock<? super E,? extends S> block)` Equivalent to `collect(TransformBlock)`.
`E`	`max()` Finds the max element.
`E`	`max(java.util.Comparator<? super E> comp)` Finds the max element compared by the Comparator.
`N`	`maxBy()` Returns an enumerator of elements.
`<S> E`	`maxBy(java.util.Comparator<? super S> comp, TransformBlock<? super E,? extends S> block)` Finds the max element for outputs transformed by the block and compared by the Comparator.
`<S> E`	`maxBy(java.lang.String methodName, java.lang.Object... args)` Finds the max element for outputs invoked by given method name.
`<S> E`	`maxBy(TransformBlock<? super E,? extends S> block)` Finds the max element for outputs transformed by the block.
`boolean`	`memberʔ(E target)` Equivalent to `includeʔ(Object)`.
`E`	`min()` Finds the min element.
`E`	`min(java.util.Comparator<? super E> comp)` Finds the min element for outputs compared by the Comparator.
`N`	`minBy()` Returns an enumerator of elements.
`<S> E`	`minBy(java.util.Comparator<? super S> comp, TransformBlock<? super E,? extends S> block)` Finds the min element for outputs transformed by the block and compared by the Comparator.
`<S> E`	`minBy(java.lang.String methodName, java.lang.Object... args)` Finds min element for outputs invoked by given method name.
`<S> E`	`minBy(TransformBlock<? super E,? extends S> block)` Finds the min element for outputs transformed by the block.
`RubyArray<E>`	`minmax()` Finds the min and max elements.
`RubyArray<E>`	`minmax(java.util.Comparator<? super E> comp)` Finds the min and max elements for outputs compared by the Comparator.
`N`	`minmaxBy()` Returns an enumerator of elements.
`<S> RubyArray<E>`	`minmaxBy(java.util.Comparator<? super S> comp, TransformBlock<? super E,? extends S> block)` Finds the min and max elements for outputs transformed by the block and compared by the Comparator.
`<S> RubyArray<E>`	`minmaxBy(java.lang.String methodName, java.lang.Object... args)` Finds the min and max elements for outputs invoked by given method name.
`<S> RubyArray<E>`	`minmaxBy(TransformBlock<? super E,? extends S> block)` Finds the min and max elements for outputs transformed by the block.
`boolean`	`noneʔ()` Checks if elements contain only null objects.
`boolean`	`noneʔ(BooleanBlock<? super E> block)` Checks if elements contain only elements which are false returned by the block.
`boolean`	`oneʔ()` Checks if elements contain only one element beside null.
`boolean`	`oneʔ(BooleanBlock<? super E> block)` Checks if elements contain only one element which are true returned by the block.
`N`	`partition()` Returns an enumerator of elements.
`RubyArray<RubyArray<E>>`	`partition(BooleanBlock<? super E> block)` Divides elements into 2 groups by the given block.
`<I> I`	`reduce(I init, java.lang.String methodName)` Equivalent to `inject(Object, String)`.
`<I> I`	`reduce(I init, WithInitBlock<? super E,I> block)` Equivalent to `inject(Object, WithInitBlock)`.
`E`	`reduce(ReduceBlock<E> block)` Equivalent to `inject(ReduceBlock)`.
`E`	`reduce(java.lang.String methodName)` Equivalent to `inject(String)`.
`N`	`reject()` Returns an enumerator of elements.
`Z`	`reject(BooleanBlock<? super E> block)` Filters all elements which are true returned by the block.
`N`	`reverseEach()` Returns a reversed enumerator of elements.
`RubyContract.Enumerable<E,N,Z>`	`reverseEach(Block<? super E> block)` Iterates each element reversely by given block.
`N`	`select()` Returns an enumerator of elements.
`Z`	`select(BooleanBlock<? super E> block)` Equivalent to `findAll(BooleanBlock)`
`N`	`sliceBefore(BooleanBlock<? super E> block)` Groups elements into `RubyArray`s and the first element of each `RubyArray` should get true returned by the block.
`N`	`sliceBefore(java.lang.String regex)` Groups elements into `RubyArray`s and the first element of each `RubyArray` should be matched by the regex.
`RubyArray<E>`	`sort()` Sorts elements and puts them into a `RubyArray`.
`N`	`sortBy()` Returns an enumerator of elements.
`<S> RubyArray<E>`	`sortBy(java.util.Comparator<? super E> comp1, java.util.Comparator<? super S> comp2, TransformBlock<? super E,? extends S> block)` Sorts elements by the ordering of outputs transformed by the block induced by the Comparator for S and applies the Comparator for E again before puts them into a `RubyArray`.
`<S> RubyArray<E>`	`sortBy(java.util.Comparator<? super S> comp, TransformBlock<? super E,? extends S> block)` Sorts elements by the ordering of outputs transformed by the block induced by the Comparator, then puts them into a `RubyArray`.
`<S> RubyArray<E>`	`sortBy(java.lang.String methodName, java.lang.Object... args)` Sorts elements by the ordering of the outputs invoked by given method name, then puts them into a `RubyArray`.
`<S> RubyArray<E>`	`sortBy(TransformBlock<? super E,? extends S> block)` Sorts elements by the ordering of outputs transformed by the block, then puts them into a `RubyArray`.
`Z`	`take(int n)` Takes the first n elements.
`N`	`takeWhile()` Returns an enumerator which contains only the first element.
`Z`	`takeWhile(BooleanBlock<? super E> block)` Takes elements until an element gets false returned by the block.
`RubyArray<E>`	`toA()` Puts all elements into a `RubyArray`.
`Z`	`zip(java.lang.Iterable<? extends E>... others)` Groups elements which get the same indices among all other Iterables into `RubyArray`s.
`Z`	`zip(java.util.List<? extends java.lang.Iterable<? extends E>> others)` Groups elements which get the same indices among all other Lists into `RubyArray`s.
`void`	`zip(java.util.List<? extends java.lang.Iterable<? extends E>> others, Block<? super RubyArray<E>> block)` Groups elements which get the same indices among all other Iterables into `RubyArray`s and yields them to the block.

Methods inherited from interface java.lang.Iterable
iterator

- Method Detail
  - allʔ
```
boolean allʔ()
```
    Checks if null is excluded.
    
    Returns:
    true if null is not found, false otherwise
  - allʔ
```
boolean allʔ(BooleanBlock<? super E> block)
```
    Checks if any result returned by the block is false.
    
    Parameters:
    block - to check elements
    
    Returns:
    true if all result are true, false otherwise
  - anyʔ
```
boolean anyʔ()
```
    Checks if any non-null object is included.
    
    Returns:
    true if non-null object is found, false otherwise
  - anyʔ
```
boolean anyʔ(BooleanBlock<? super E> block)
```
    Checks if any result returned by the block is true.
    
    Parameters:
    block - to check elements
    
    Returns:
    true if any result are true, false otherwise
  - chunk
```
<S> N chunk(TransformBlock<? super E,? extends S> block)
```
    Chunks elements into entries. The key of entry is the result returned by the block. The value of entry is a RubyArray which contains elements having the same result returned by the block and aside to each other.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to chunk elements
    
    Returns:
    RubyContract.Enumerator
  - chunk
```
<S> N chunk(java.lang.String methodName,
          java.lang.Object... args)
```
    Chunks elements into entries. The key of entry is the result invoked by the given method name. The value of entry is a RubyArray which contains elements having the same result returned by the block and aside to each other.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyContract.Enumerator
  - collect
```
N collect()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - collect
```
<S> Z collect(TransformBlock<? super E,? extends S> block)
```
    Transforms each element by the block.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyContract.Enumerable
  - collect
```
<S> Z collect(java.lang.String methodName,
            java.lang.Object... args)
```
    Transforms each element by given method.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyContract.Enumerable
  - collectConcat
```
N collectConcat()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - collectConcat
```
<S> Z collectConcat(TransformBlock<? super E,? extends java.util.List<? extends S>> block)
```
    Turns each element into a List and then flattens it.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to take element into a List
    
    Returns:
    RubyContract.Enumerable
  - count
```
int count()
```
    Counts the elements.
    
    Returns:
    the total number
  - count
```
int count(BooleanBlock<? super E> block)
```
    Counts the elements which are true returned by the block.
    
    Parameters:
    block - to define elements to be counted
    
    Returns:
    the total number
  - cycle
```
N cycle()
```
    Generates a sequence from first element to last element and so on infinitely.
    
    Returns:
    RubyContract.Enumerator
  - cycle
```
N cycle(int n)
```
    Generates a sequence from first element to last element, repeat n times.
    
    Parameters:
    n - times to repeat
    
    Returns:
    RubyContract.Enumerator
  - cycle
```
void cycle(int n,
         Block<? super E> block)
```
    Generates a sequence from start element to end element, repeat n times. Yields each element to the block.
    
    Parameters:
    n - times to repeat
    block - to yield each element
  - cycle
```
void cycle(Block<? super E> block)
```
    Generates a sequence from start element to end element and so on infinitely. Yields each element to the block.
    
    Parameters:
    block - to yield each element
  - detect
```
N detect()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - detect
```
E detect(BooleanBlock<? super E> block)
```
    Finds the first element which gets true returned by the block. Returns null if element is not found.
    
    Parameters:
    block - to filter elements
    
    Returns:
    element or null
  - drop
```
Z drop(int n)
```
    Drops the first n elements.
    
    Parameters:
    n - number of elements to drop
    
    Returns:
    RubyContract.Enumerable
  - dropWhile
```
N dropWhile()
```
    Returns an enumerator which contains only the first element.
    
    Returns:
    RubyContract.Enumerator
  - dropWhile
```
Z dropWhile(BooleanBlock<? super E> block)
```
    Drops the first n elements until an element gets false returned by the block.
    
    Parameters:
    block - to define which elements to be dropped
    
    Returns:
    RubyContract.Enumerable
  - each
```
N each()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - each
```
RubyContract.Enumerable<E,N,Z> each(Block<? super E> block)
```
    Yields each element to the block.
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyContract.Enumerable
  - eachCons
```
N eachCons(int n)
```
    Iterates each element and puts the element with n - 1 consecutive elements into a RubyArray.
    
    Parameters:
    n - number of consecutive elements
    
    Returns:
    RubyContract.Enumerator
  - eachCons
```
void eachCons(int n,
            Block<? super RubyArray<E>> block)
```
    Iterates each element and yields the element with n - 1 consecutive elements to the block.
    
    Parameters:
    n - number of consecutive elements
    block - to yield the List of consecutive elements
  - eachEntry
```
N eachEntry()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - eachEntry
```
RubyContract.Enumerable<E,N,Z> eachEntry(Block<? super E> block)
```
    Yields each element to the block.
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyContract.Enumerable
  - eachSlice
```
N eachSlice(int n)
```
    Slices elements into RubyArrays with length n.
    
    Parameters:
    n - size of each slice
    
    Returns:
    RubyContract.Enumerator
  - eachSlice
```
void eachSlice(int n,
             Block<? super RubyArray<E>> block)
```
    Slices elements into RubyArrays with length n and yield them to the block.
    
    Parameters:
    n - size of each slice
    block - to yield each slice
  - eachWithIndex
```
N eachWithIndex()
```
    Iterates elements with their indices by Entry.
    
    Returns:
    RubyContract.Enumerator
  - eachWithIndex
```
RubyContract.Enumerable<E,N,Z> eachWithIndex(WithIndexBlock<? super E> block)
```
    Iterates elements with their indices and yields them to the block.
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyContract.Enumerable
  - eachWithObject
```
<O> N eachWithObject(O obj)
```
    Iterates elements with an object O.
    
    Type Parameters:
    O - the type of transformed elements
    Parameters:
    obj - an object O
    
    Returns:
    RubyContract.Enumerator
  - eachWithObject
```
<O> O eachWithObject(O obj,
                   WithObjectBlock<? super E,? super O> block)
```
    Iterates elements with an object O and yield them to the block.
    
    Type Parameters:
    O - the type of transformed elements
    Parameters:
    obj - an object O
    block - to yield each Entry
    
    Returns:
    the object O
  - entries
```
RubyArray<E> entries()
```
    Puts each element into a RubyArray.
    
    Returns:
    RubyArray
  - find
```
N find()
```
    Equivalent to detect().
    
    Returns:
    RubyContract.Enumerator
  - find
```
E find(BooleanBlock<? super E> block)
```
    Equivalent to detect(BooleanBlock).
    
    Parameters:
    block - to filter elements
    
    Returns:
    element or null
  - findAll
```
N findAll()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - findAll
```
Z findAll(BooleanBlock<? super E> block)
```
    Finds all elements which are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyContract.Enumerable
  - findIndex
```
N findIndex()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - findIndex
```
java.lang.Integer findIndex(BooleanBlock<? super E> block)
```
    Returns the index of first element which gets true returned by the block. Returns null if nothing is found.
    
    Parameters:
    block - to check elements
    
    Returns:
    Integer or null
  - findIndex
```
java.lang.Integer findIndex(E target)
```
    Returns the index of the target element. Returns null if the target is not found.
    
    Parameters:
    target - to be found
    
    Returns:
    Integer or null
  - first
```
E first()
```
    Returns first element. Returns null if elements are empty.
    
    Returns:
    element or null
  - first
```
RubyArray<E> first(int n)
```
    Returns the first n elements.
    
    Parameters:
    n - number of elements
    
    Returns:
    RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is less than 0
  - flatMap
```
N flatMap()
```
    Equivalent to collectConcat().
    
    Returns:
    RubyContract.Enumerator
  - flatMap
```
<S> Z flatMap(TransformBlock<? super E,? extends java.util.List<? extends S>> block)
```
    Equivalent to collectConcat(TransformBlock).
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to take element into a List
    
    Returns:
    RubyContract.Enumerable
  - grep
```
Z grep(java.lang.String regex)
```
    Finds all elements which are matched by the regular expression.
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyContract.Enumerable
  - grep
```
<S> Z grep(java.lang.String regex,
         TransformBlock<? super E,? extends S> block)
```
    Finds all elements which are matched by the regular expression and transforms them.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    regex - regular expression
    block - to transform elements
    
    Returns:
    RubyContract.Enumerable
  - grep
```
<S> Z grep(java.lang.String regex,
         java.lang.String methodName,
         java.lang.Object... args)
```
    Finds all elements which are matched by the regular expression and invokes them by given method name.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    regex - regular expression
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyContract.Enumerable
  - groupBy
```
N groupBy()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - groupBy
```
<S> RubyHash<S,RubyArray<E>> groupBy(TransformBlock<? super E,? extends S> block)
```
    Puts elements with the same result S returned by the block into a Entry<S, RubyArray<E>>y of a RubyHash.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to group each element
    
    Returns:
    RubyHash
  - groupBy
```
<S> RubyHash<S,RubyArray<E>> groupBy(java.lang.String methodName,
                                   java.lang.Object... args)
```
    Puts elements with the same result S invoked by given method name into a Entry<S, RubyArray<E>>y of a RubyHash.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyHash
  - includeʔ
```
boolean includeʔ(E target)
```
    Checks if target element is included.
    
    Parameters:
    target - to be searched
    
    Returns:
    true if target is found,false otherwise
  - inject
```
E inject(ReduceBlock<E> block)
```
    Assigns the first element as the initial value. Reduces each element with block, then assigns the result back to initial value and so on.
    
    Parameters:
    block - to reduce each element
    
    Returns:
    element
  - inject
```
<I> I inject(I init,
           WithInitBlock<? super E,I> block)
```
    Reduces each element with block, then assigns the result back to initial value and so on.
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    block - to reduce each element
    
    Returns:
    object I
  - inject
```
<I> I inject(I init,
           java.lang.String methodName)
```
    Reduces each element with initial value by a method of S, then assigns the result back to initial value and so on.
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    methodName - method used to reduce elements
    
    Returns:
    object I
    
    Throws:
    
    java.lang.IllegalArgumentException - if method not found
    
    java.lang.RuntimeException - if invocation failed
  - inject
```
E inject(java.lang.String methodName)
```
    Assigns the first element as the initial value. Reduces each element with initial value by a method of S, then assigns the result back to initial value and so on.
    
    Parameters:
    methodName - method used to reduce elements
    
    Returns:
    element
    
    Throws:
    
    java.lang.IllegalArgumentException - if method not found
    
    java.lang.RuntimeException - if invocation failed
  - lazy
```
RubyLazyEnumerator<E> lazy()
```
    Returns a RubyLazyEnumerator.
    
    Returns:
    RubyLazyEnumerator
  - map
```
N map()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - map
```
<S> Z map(TransformBlock<? super E,? extends S> block)
```
    Equivalent to collect(TransformBlock).
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyContract.Enumerable
  - map
```
<S> Z map(java.lang.String methodName,
        java.lang.Object... args)
```
    Equivalent to collect(String, Object...).
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyContract.Enumerable
  - max
```
E max()
```
    Finds the max element. Returns null if elements are empty.
    
    Returns:
    element or null
  - max
```
E max(java.util.Comparator<? super E> comp)
```
    Finds the max element compared by the Comparator. Returns null if elements are empty.
    
    Parameters:
    comp - a Comparator
    
    Returns:
    element or null
  - maxBy
```
N maxBy()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - maxBy
```
<S> E maxBy(java.util.Comparator<? super S> comp,
          TransformBlock<? super E,? extends S> block)
```
    Finds the max element for outputs transformed by the block and compared by the Comparator. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    element or null
  - maxBy
```
<S> E maxBy(TransformBlock<? super E,? extends S> block)
```
    Finds the max element for outputs transformed by the block. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    element or null
  - maxBy
```
<S> E maxBy(java.lang.String methodName,
          java.lang.Object... args)
```
    Finds the max element for outputs invoked by given method name. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    element or null
  - memberʔ
```
boolean memberʔ(E target)
```
    Equivalent to includeʔ(Object).
    
    Parameters:
    target - to be found
    
    Returns:
    element or null
  - min
```
E min()
```
    Finds the min element. Returns null if elements are empty.
    
    Returns:
    element or null
  - min
```
E min(java.util.Comparator<? super E> comp)
```
    Finds the min element for outputs compared by the Comparator. Returns null if elements are empty.
    
    Parameters:
    comp - a Comparator
    
    Returns:
    element or null
  - minBy
```
N minBy()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - minBy
```
<S> E minBy(java.util.Comparator<? super S> comp,
          TransformBlock<? super E,? extends S> block)
```
    Finds the min element for outputs transformed by the block and compared by the Comparator. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    element or null
  - minBy
```
<S> E minBy(TransformBlock<? super E,? extends S> block)
```
    Finds the min element for outputs transformed by the block. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    element or null
  - minBy
```
<S> E minBy(java.lang.String methodName,
          java.lang.Object... args)
```
    Finds min element for outputs invoked by given method name. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    element or null
  - minmax
```
RubyArray<E> minmax()
```
    Finds the min and max elements.
    
    Returns:
    RubyArray
  - minmax
```
RubyArray<E> minmax(java.util.Comparator<? super E> comp)
```
    Finds the min and max elements for outputs compared by the Comparator.
    
    Parameters:
    comp - a Comparator
    
    Returns:
    RubyArray
  - minmaxBy
```
N minmaxBy()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - minmaxBy
```
<S> RubyArray<E> minmaxBy(java.util.Comparator<? super S> comp,
                        TransformBlock<? super E,? extends S> block)
```
    Finds the min and max elements for outputs transformed by the block and compared by the Comparator.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    RubyArray
  - minmaxBy
```
<S> RubyArray<E> minmaxBy(TransformBlock<? super E,? extends S> block)
```
    Finds the min and max elements for outputs transformed by the block.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyArray
  - minmaxBy
```
<S> RubyArray<E> minmaxBy(java.lang.String methodName,
                        java.lang.Object... args)
```
    Finds the min and max elements for outputs invoked by given method name. Returns null if elements are empty.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyArray
  - noneʔ
```
boolean noneʔ()
```
    Checks if elements contain only null objects.
    
    Returns:
    true if all elements are null, false otherwise
  - noneʔ
```
boolean noneʔ(BooleanBlock<? super E> block)
```
    Checks if elements contain only elements which are false returned by the block.
    
    Parameters:
    block - to check elements
    
    Returns:
    true if all results of block are false, false otherwise
  - oneʔ
```
boolean oneʔ()
```
    Checks if elements contain only one element beside null.
    
    Returns:
    true if only one element beside null is found, false otherwise
  - oneʔ
```
boolean oneʔ(BooleanBlock<? super E> block)
```
    Checks if elements contain only one element which are true returned by the block.
    
    Parameters:
    block - to check elements
    
    Returns:
    true if only one result of block is true, false otherwise
  - partition
```
N partition()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - partition
```
RubyArray<RubyArray<E>> partition(BooleanBlock<? super E> block)
```
    Divides elements into 2 groups by the given block.
    
    Parameters:
    block - to part elements
    
    Returns:
    RubyArray of 2 RubyArrays
  - reduce
```
E reduce(ReduceBlock<E> block)
```
    Equivalent to inject(ReduceBlock).
    
    Parameters:
    block - to reduce each element
    
    Returns:
    element
  - reduce
```
<I> I reduce(I init,
           WithInitBlock<? super E,I> block)
```
    Equivalent to inject(Object, WithInitBlock).
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    block - to reduce each element
    
    Returns:
    object I
  - reduce
```
<I> I reduce(I init,
           java.lang.String methodName)
```
    Equivalent to inject(Object, String).
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    methodName - method used to reduce elements
    
    Returns:
    object I
    
    Throws:
    
    java.lang.IllegalArgumentException - if method not found
    
    java.lang.RuntimeException - if invocation failed
  - reduce
```
E reduce(java.lang.String methodName)
```
    Equivalent to inject(String).
    
    Parameters:
    methodName - method used to reduce elements
    
    Returns:
    element
    
    Throws:
    
    java.lang.IllegalArgumentException - if method not found
    
    java.lang.RuntimeException - if invocation failed
  - reject
```
N reject()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - reject
```
Z reject(BooleanBlock<? super E> block)
```
    Filters all elements which are true returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyContract.Enumerable
  - reverseEach
```
N reverseEach()
```
    Returns a reversed enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - reverseEach
```
RubyContract.Enumerable<E,N,Z> reverseEach(Block<? super E> block)
```
    Iterates each element reversely by given block.
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyContract.Enumerable
  - select
```
N select()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - select
```
Z select(BooleanBlock<? super E> block)
```
    Equivalent to findAll(BooleanBlock)
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyContract.Enumerable
  - sliceBefore
```
N sliceBefore(BooleanBlock<? super E> block)
```
    Groups elements into RubyArrays and the first element of each RubyArray should get true returned by the block.
    
    Parameters:
    block - to check where to do slice
    
    Returns:
    RubyContract.Enumerator
  - sliceBefore
```
N sliceBefore(java.lang.String regex)
```
    Groups elements into RubyArrays and the first element of each RubyArray should be matched by the regex.
    
    Parameters:
    regex - to check where to do slice
    
    Returns:
    RubyContract.Enumerator
  - sort
```
RubyArray<E> sort()
```
    Sorts elements and puts them into a RubyArray.
    
    Returns:
    RubyArray
    
    Throws:
    
    java.lang.IllegalArgumentException - when any 2 elements are not comparable
  - sortBy
```
N sortBy()
```
    Returns an enumerator of elements.
    
    Returns:
    RubyContract.Enumerator
  - sortBy
```
<S> RubyArray<E> sortBy(java.util.Comparator<? super S> comp,
                      TransformBlock<? super E,? extends S> block)
```
    Sorts elements by the ordering of outputs transformed by the block induced by the Comparator, then puts them into a RubyArray.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    RubyArray
  - sortBy
```
<S> RubyArray<E> sortBy(java.util.Comparator<? super E> comp1,
                      java.util.Comparator<? super S> comp2,
                      TransformBlock<? super E,? extends S> block)
```
    Sorts elements by the ordering of outputs transformed by the block induced by the Comparator for S and applies the Comparator for E again before puts them into a RubyArray.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp1 - a Comparator for E
    comp2 - a Comparator for S
    block - to transform elements
    
    Returns:
    RubyArray
  - sortBy
```
<S> RubyArray<E> sortBy(TransformBlock<? super E,? extends S> block)
```
    Sorts elements by the ordering of outputs transformed by the block, then puts them into a RubyArray.
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyArray
  - sortBy
```
<S> RubyArray<E> sortBy(java.lang.String methodName,
                      java.lang.Object... args)
```
    Sorts elements by the ordering of the outputs invoked by given method name, then puts them into a RubyArray.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyArray
  - take
```
Z take(int n)
```
    Takes the first n elements.
    
    Parameters:
    n - number of elements
    
    Returns:
    RubyContract.Enumerable
  - takeWhile
```
N takeWhile()
```
    Returns an enumerator which contains only the first element.
    
    Returns:
    RubyContract.Enumerator
  - takeWhile
```
Z takeWhile(BooleanBlock<? super E> block)
```
    Takes elements until an element gets false returned by the block.
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyContract.Enumerable
  - toA
```
RubyArray<E> toA()
```
    Puts all elements into a RubyArray.
    
    Returns:
    RubyArray
  - zip
```
Z zip(java.lang.Iterable<? extends E>... others)
```
    Groups elements which get the same indices among all other Iterables into RubyArrays.
    
    Parameters:
    others - an array of Iterable
    
    Returns:
    RubyContract.Enumerable
  - zip
```
Z zip(java.util.List<? extends java.lang.Iterable<? extends E>> others)
```
    Groups elements which get the same indices among all other Lists into RubyArrays.
    
    Parameters:
    others - a List of Iterable
    
    Returns:
    RubyContract.Enumerable
  - zip
```
void zip(java.util.List<? extends java.lang.Iterable<? extends E>> others,
       Block<? super RubyArray<E>> block)
```
    Groups elements which get the same indices among all other Iterables into RubyArrays and yields them to the block.
    
    Parameters:
    others - a List of Iterables
    block - to yield zipped elements

Interface RubyContract.Enumerable<E,N extends RubyContract.Enumerator<?,?,?>,Z extends RubyContract.Enumerable<?,?,?>>

Method Summary

Methods inherited from interface java.lang.Iterable

Method Detail

allʔ

allʔ

anyʔ

anyʔ

chunk

chunk

collect

collect

collect

collectConcat

collectConcat

count

count

cycle

cycle

cycle

cycle

detect

detect

drop

dropWhile

dropWhile

each

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