RubyLazyEnumerator

java.lang.Object
- net.sf.rubycollect4j.RubyLazyEnumerator<E>

Type Parameters:
E - the type of the elements

All Implemented Interfaces:

java.lang.Iterable<E>, java.util.Iterator<E>, Ruby.LazyEnumerator<E>, RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>, RubyContract.Enumerator<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
```
public final class RubyLazyEnumerator<E>
extends java.lang.Object
implements Ruby.LazyEnumerator<E>
```
RubyLazyEnumerator implements most of the methods refer to the Enumerator::Lazy class of Ruby language.
RubyLazyEnumerator is both Iterable and Iterator and it's also a peeking iterator.

Constructor Summary

Constructors
Constructor and Description

RubyLazyEnumerator(java.lang.Iterable<E> iterable)
Creates a RubyLazyEnumerator by given Iterable.

Constructors
Constructor and Description
`RubyLazyEnumerator(java.lang.Iterable<E> iterable)` Creates a `RubyLazyEnumerator` by given Iterable.

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> RubyLazyEnumerator<java.util.Map.Entry<S,RubyArray<E>>>`	`chunk(java.lang.String methodName, java.lang.Object... args)` Chunks elements into entries.
`<S> RubyLazyEnumerator<java.util.Map.Entry<S,RubyArray<E>>>`	`chunk(TransformBlock<? super E,? extends S> block)` Chunks elements into entries.
`RubyLazyEnumerator<E>`	`collect()` Returns an enumerator of elements.
`<S> RubyLazyEnumerator<S>`	`collect(java.lang.String methodName, java.lang.Object... args)` Transforms each element by given method.
`<S> RubyLazyEnumerator<S>`	`collect(TransformBlock<? super E,? extends S> block)` Transforms each element by the block.
`RubyLazyEnumerator<E>`	`collectConcat()` Returns an enumerator of elements.
`<S> RubyLazyEnumerator<S>`	`collectConcat(TransformBlock<? super E,? extends java.util.List<? extends S>> block)` Turns each element into a List and then flattens it.
`static <E> RubyLazyEnumerator<E>`	`copyOf(java.lang.Iterable<E> iter)` Returns a `RubyLazyEnumerator` which copies the elements of given Iterable.
`int`	`count()` Counts the elements.
`int`	`count(BooleanBlock<? super E> block)` Counts the elements which are true returned by the block.
`RubyLazyEnumerator<E>`	`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.
`RubyLazyEnumerator<E>`	`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.
`RubyLazyEnumerator<E>`	`detect()` Returns an enumerator of elements.
`E`	`detect(BooleanBlock<? super E> block)` Finds the first element which gets true returned by the block.
`RubyLazyEnumerator<E>`	`drop(int n)` Drops the first n elements.
`RubyLazyEnumerator<E>`	`dropWhile()` Returns an enumerator which contains only the first element.
`RubyLazyEnumerator<E>`	`dropWhile(BooleanBlock<? super E> block)` Drops the first n elements until an element gets false returned by the block.
`RubyLazyEnumerator<E>`	`each()` Returns an enumerator of elements.
`RubyLazyEnumerator<E>`	`each(Block<? super E> block)` Yields each element to the block.
`RubyLazyEnumerator<RubyArray<E>>`	`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.
`RubyLazyEnumerator<E>`	`eachEntry()` Returns an enumerator of elements.
`RubyLazyEnumerator<E>`	`eachEntry(Block<? super E> block)` Yields each element to the block.
`RubyLazyEnumerator<RubyArray<E>>`	`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.
`RubyLazyEnumerator<java.util.Map.Entry<E,java.lang.Integer>>`	`eachWithIndex()` Iterates elements with their indices by Entry.
`RubyLazyEnumerator<E>`	`eachWithIndex(WithIndexBlock<? super E> block)` Iterates elements with their indices and yields them to the block.
`<O> RubyLazyEnumerator<java.util.Map.Entry<E,O>>`	`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`.
`RubyLazyEnumerator<E>`	`find()` Equivalent to `RubyContract.Enumerable.detect()`.
`E`	`find(BooleanBlock<? super E> block)` Equivalent to `RubyContract.Enumerable.detect(BooleanBlock)`.
`RubyLazyEnumerator<E>`	`findAll()` Returns an enumerator of elements.
`RubyLazyEnumerator<E>`	`findAll(BooleanBlock<? super E> block)` Finds all elements which are true returned by the block.
`RubyLazyEnumerator<E>`	`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.
`RubyLazyEnumerator<E>`	`flatMap()` Equivalent to `RubyContract.Enumerable.collectConcat()`.
`<S> RubyLazyEnumerator<S>`	`flatMap(TransformBlock<? super E,? extends java.util.List<? extends S>> block)` Equivalent to `RubyContract.Enumerable.collectConcat(TransformBlock)`.
`RubyLazyEnumerator<E>`	`grep(java.lang.String regex)` Finds all elements which are matched by the regular expression.
`<S> RubyLazyEnumerator<S>`	`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> RubyLazyEnumerator<S>`	`grep(java.lang.String regex, TransformBlock<? super E,? extends S> block)` Finds all elements which are matched by the regular expression and transforms them.
`RubyLazyEnumerator<E>`	`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`	`hasNext()`
`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.
`java.util.Iterator<E>`	`iterator()`
`RubyLazyEnumerator<E>`	`lazy()` Returns a `RubyLazyEnumerator`.
`RubyLazyEnumerator<E>`	`map()` Returns an enumerator of elements.
`<S> RubyLazyEnumerator<S>`	`map(java.lang.String methodName, java.lang.Object... args)` Equivalent to `RubyContract.Enumerable.collect(String, Object...)`.
`<S> RubyLazyEnumerator<S>`	`map(TransformBlock<? super E,? extends S> block)` Equivalent to `RubyContract.Enumerable.collect(TransformBlock)`.
`E`	`max()` Finds the max element.
`E`	`max(java.util.Comparator<? super E> comp)` Finds the max element compared by the Comparator.
`RubyLazyEnumerator<E>`	`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 `RubyContract.Enumerable.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.
`RubyLazyEnumerator<E>`	`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.
`RubyLazyEnumerator<E>`	`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.
`E`	`next()`
`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.
`static <E> RubyLazyEnumerator<E>`	`of(java.lang.Iterable<E> iter)` Returns a `RubyLazyEnumerator` which wraps the given Iterable.
`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.
`RubyLazyEnumerator<E>`	`partition()` Returns an enumerator of elements.
`RubyArray<RubyArray<E>>`	`partition(BooleanBlock<? super E> block)` Divides elements into 2 groups by the given block.
`E`	`peek()` Returns the next element without advancing the iteration.
`E`	`reduce(ReduceBlock<E> block)` Equivalent to `RubyContract.Enumerable.inject(ReduceBlock)`.
`<S> S`	`reduce(S init, java.lang.String methodName)` Equivalent to `RubyContract.Enumerable.inject(Object, String)`.
`E`	`reduce(java.lang.String methodName)` Equivalent to `RubyContract.Enumerable.inject(String)`.
`<S> S`	`reduce(S init, WithInitBlock<? super E,S> block)` Equivalent to `RubyContract.Enumerable.inject(Object, WithInitBlock)`.
`RubyLazyEnumerator<E>`	`reject()` Returns an enumerator of elements.
`RubyLazyEnumerator<E>`	`reject(BooleanBlock<? super E> block)` Filters all elements which are true returned by the block.
`void`	`remove()`
`RubyLazyEnumerator<E>`	`reverseEach()` Returns a reversed enumerator of elements.
`RubyLazyEnumerator<E>`	`reverseEach(Block<? super E> block)` Iterates each element reversely by given block.
`RubyLazyEnumerator<E>`	`rewind()` Rewinds this Iterator to the beginning.
`RubyLazyEnumerator<E>`	`select()` Returns an enumerator of elements.
`RubyLazyEnumerator<E>`	`select(BooleanBlock<? super E> block)` Equivalent to `RubyContract.Enumerable.findAll(BooleanBlock)`
`RubyLazyEnumerator<RubyArray<E>>`	`sliceBefore(BooleanBlock<? super E> block)` Groups elements into `RubyArray`s and the first element of each `RubyArray` should get true returned by the block.
`RubyLazyEnumerator<RubyArray<E>>`	`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`.
`RubyLazyEnumerator<E>`	`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`.
`RubyLazyEnumerator<E>`	`take(int n)` Takes the first n elements.
`RubyLazyEnumerator<E>`	`takeWhile()` Returns an enumerator which contains only the first element.
`RubyLazyEnumerator<E>`	`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`.
`java.lang.String`	`toString()`
`RubyLazyEnumerator<RubyArray<E>>`	`zip(java.lang.Iterable<? extends E>... others)` Groups elements which get the same indices among all other Iterables into `RubyArray`s.
`RubyLazyEnumerator<RubyArray<E>>`	`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 class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - RubyLazyEnumerator
```
public RubyLazyEnumerator(java.lang.Iterable<E> iterable)
```
    Creates a RubyLazyEnumerator by given Iterable. It's a wrapper implementation. No defensive copy has been made.
    
    Parameters:
    iterable - any Iterable
    
    Throws:
    
    java.lang.NullPointerException - if iterable is null
- Method Detail
  - of
```
public static <E> RubyLazyEnumerator<E> of(java.lang.Iterable<E> iter)
```
    Returns a RubyLazyEnumerator which wraps the given Iterable.
    
    Parameters:
    iter - any Iterable
    
    Returns:
    RubyLazyEnumerator
    
    Throws:
    
    java.lang.NullPointerException - if iter is null
  - copyOf
```
public static <E> RubyLazyEnumerator<E> copyOf(java.lang.Iterable<E> iter)
```
    Returns a RubyLazyEnumerator which copies the elements of given Iterable.
    
    Parameters:
    iter - any Iterable
    
    Returns:
    RubyLazyEnumerator
    
    Throws:
    
    java.lang.NullPointerException - if iter is null
  - allʔ
```
public boolean allʔ()
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if null is excluded.
    
    Specified by:
    
    allʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    true if null is not found, false otherwise
  - allʔ
```
public boolean allʔ(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if any result returned by the block is false.
    
    Specified by:
    
    allʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check elements
    
    Returns:
    true if all result are true, false otherwise
  - anyʔ
```
public boolean anyʔ()
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if any non-null object is included.
    
    Specified by:
    
    anyʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    true if non-null object is found, false otherwise
  - anyʔ
```
public boolean anyʔ(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if any result returned by the block is true.
    
    Specified by:
    
    anyʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check elements
    
    Returns:
    true if any result are true, false otherwise
  - chunk
```
public <S> RubyLazyEnumerator<java.util.Map.Entry<S,RubyArray<E>>> 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.
    
    Specified by:
    
    chunk in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    chunk in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to chunk elements
    
    Returns:
    RubyLazyEnumerator
  - chunk
```
public <S> RubyLazyEnumerator<java.util.Map.Entry<S,RubyArray<E>>> 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.
    
    Specified by:
    
    chunk in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    chunk in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyLazyEnumerator
  - collect
```
public RubyLazyEnumerator<E> collect()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    collect in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    collect in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - collect
```
public <S> RubyLazyEnumerator<S> collect(TransformBlock<? super E,? extends S> block)
```
    Transforms each element by the block.
    
    Specified by:
    
    collect in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    collect in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyLazyEnumerator
  - collect
```
public <S> RubyLazyEnumerator<S> collect(java.lang.String methodName,
                                java.lang.Object... args)
```
    Transforms each element by given method.
    
    Specified by:
    
    collect in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    collect in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyLazyEnumerator
  - collectConcat
```
public RubyLazyEnumerator<E> collectConcat()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    collectConcat in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    collectConcat in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - collectConcat
```
public <S> RubyLazyEnumerator<S> collectConcat(TransformBlock<? super E,? extends java.util.List<? extends S>> block)
```
    Turns each element into a List and then flattens it.
    
    Specified by:
    
    collectConcat in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    collectConcat in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to take element into a List
    
    Returns:
    RubyLazyEnumerator
  - count
```
public int count()
```
    Description copied from interface: RubyContract.Enumerable
    
    Counts the elements.
    
    Specified by:
    
    count in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    the total number
  - count
```
public int count(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Counts the elements which are true returned by the block.
    
    Specified by:
    
    count in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to define elements to be counted
    
    Returns:
    the total number
  - cycle
```
public RubyLazyEnumerator<E> cycle()
```
    Generates a sequence from first element to last element and so on infinitely.
    
    Specified by:
    
    cycle in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    cycle in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - cycle
```
public RubyLazyEnumerator<E> cycle(int n)
```
    Generates a sequence from first element to last element, repeat n times.
    
    Specified by:
    
    cycle in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    cycle in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - times to repeat
    
    Returns:
    RubyLazyEnumerator
  - cycle
```
public void cycle(int n,
         Block<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Generates a sequence from start element to end element, repeat n times. Yields each element to the block.
    
    Specified by:
    
    cycle in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - times to repeat
    block - to yield each element
  - cycle
```
public void cycle(Block<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Generates a sequence from start element to end element and so on infinitely. Yields each element to the block.
    
    Specified by:
    
    cycle in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to yield each element
  - detect
```
public RubyLazyEnumerator<E> detect()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    detect in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    detect in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - detect
```
public E detect(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the first element which gets true returned by the block. Returns null if element is not found.
    
    Specified by:
    
    detect in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    element or null
  - drop
```
public RubyLazyEnumerator<E> drop(int n)
```
    Drops the first n elements.
    
    Specified by:
    
    drop in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    drop in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - number of elements to drop
    
    Returns:
    RubyLazyEnumerator
  - dropWhile
```
public RubyLazyEnumerator<E> dropWhile()
```
    Returns an enumerator which contains only the first element.
    
    Specified by:
    
    dropWhile in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    dropWhile in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - dropWhile
```
public RubyLazyEnumerator<E> dropWhile(BooleanBlock<? super E> block)
```
    Drops the first n elements until an element gets false returned by the block.
    
    Specified by:
    
    dropWhile in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    dropWhile in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to define which elements to be dropped
    
    Returns:
    RubyLazyEnumerator
  - each
```
public RubyLazyEnumerator<E> each()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    each in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    each in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - each
```
public RubyLazyEnumerator<E> each(Block<? super E> block)
```
    Yields each element to the block.
    
    Specified by:
    
    each in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    each in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyLazyEnumerator
  - eachCons
```
public RubyLazyEnumerator<RubyArray<E>> eachCons(int n)
```
    Iterates each element and puts the element with n - 1 consecutive elements into a RubyArray.
    
    Specified by:
    
    eachCons in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachCons in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - number of consecutive elements
    
    Returns:
    RubyLazyEnumerator
  - eachCons
```
public void eachCons(int n,
            Block<? super RubyArray<E>> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Iterates each element and yields the element with n - 1 consecutive elements to the block.
    
    Specified by:
    
    eachCons in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - number of consecutive elements
    block - to yield the List of consecutive elements
  - eachEntry
```
public RubyLazyEnumerator<E> eachEntry()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    eachEntry in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachEntry in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - eachEntry
```
public RubyLazyEnumerator<E> eachEntry(Block<? super E> block)
```
    Yields each element to the block.
    
    Specified by:
    
    eachEntry in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachEntry in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyLazyEnumerator
  - eachSlice
```
public RubyLazyEnumerator<RubyArray<E>> eachSlice(int n)
```
    Slices elements into RubyArrays with length n.
    
    Specified by:
    
    eachSlice in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachSlice in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - size of each slice
    
    Returns:
    RubyLazyEnumerator
  - eachSlice
```
public void eachSlice(int n,
             Block<? super RubyArray<E>> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Slices elements into RubyArrays with length n and yield them to the block.
    
    Specified by:
    
    eachSlice in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - size of each slice
    block - to yield each slice
  - eachWithIndex
```
public RubyLazyEnumerator<java.util.Map.Entry<E,java.lang.Integer>> eachWithIndex()
```
    Iterates elements with their indices by Entry.
    
    Specified by:
    
    eachWithIndex in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachWithIndex in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - eachWithIndex
```
public RubyLazyEnumerator<E> eachWithIndex(WithIndexBlock<? super E> block)
```
    Iterates elements with their indices and yields them to the block.
    
    Specified by:
    
    eachWithIndex in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachWithIndex in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyLazyEnumerator
  - eachWithObject
```
public <O> RubyLazyEnumerator<java.util.Map.Entry<E,O>> eachWithObject(O obj)
```
    Iterates elements with an object O.
    
    Specified by:
    
    eachWithObject in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    eachWithObject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    O - the type of transformed elements
    Parameters:
    obj - an object O
    
    Returns:
    RubyLazyEnumerator
  - eachWithObject
```
public <O> O eachWithObject(O obj,
                   WithObjectBlock<? super E,? super O> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Iterates elements with an object O and yield them to the block.
    
    Specified by:
    
    eachWithObject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    O - the type of transformed elements
    Parameters:
    obj - an object O
    block - to yield each Entry
    
    Returns:
    the object O
  - entries
```
public RubyArray<E> entries()
```
    Description copied from interface: RubyContract.Enumerable
    
    Puts each element into a RubyArray.
    
    Specified by:
    
    entries in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyArray
  - find
```
public RubyLazyEnumerator<E> find()
```
    Equivalent to RubyContract.Enumerable.detect().
    
    Specified by:
    
    find in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    find in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - findAll
```
public RubyLazyEnumerator<E> findAll()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    findAll in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    findAll in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - find
```
public E find(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.detect(BooleanBlock).
    
    Specified by:
    
    find in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    element or null
  - findAll
```
public RubyLazyEnumerator<E> findAll(BooleanBlock<? super E> block)
```
    Finds all elements which are true returned by the block.
    
    Specified by:
    
    findAll in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    findAll in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyLazyEnumerator
  - findIndex
```
public RubyLazyEnumerator<E> findIndex()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    findIndex in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    findIndex in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - findIndex
```
public java.lang.Integer findIndex(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Returns the index of first element which gets true returned by the block. Returns null if nothing is found.
    
    Specified by:
    
    findIndex in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check elements
    
    Returns:
    Integer or null
  - findIndex
```
public java.lang.Integer findIndex(E target)
```
    Description copied from interface: RubyContract.Enumerable
    
    Returns the index of the target element. Returns null if the target is not found.
    
    Specified by:
    
    findIndex in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    target - to be found
    
    Returns:
    Integer or null
  - first
```
public E first()
```
    Description copied from interface: RubyContract.Enumerable
    
    Returns first element. Returns null if elements are empty.
    
    Specified by:
    
    first in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    element or null
  - first
```
public RubyArray<E> first(int n)
```
    Description copied from interface: RubyContract.Enumerable
    
    Returns the first n elements.
    
    Specified by:
    
    first in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - number of elements
    
    Returns:
    RubyArray
  - flatMap
```
public RubyLazyEnumerator<E> flatMap()
```
    Equivalent to RubyContract.Enumerable.collectConcat().
    
    Specified by:
    
    flatMap in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    flatMap in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - flatMap
```
public <S> RubyLazyEnumerator<S> flatMap(TransformBlock<? super E,? extends java.util.List<? extends S>> block)
```
    Equivalent to RubyContract.Enumerable.collectConcat(TransformBlock).
    
    Specified by:
    
    flatMap in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    flatMap in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to take element into a List
    
    Returns:
    RubyLazyEnumerator
  - grep
```
public RubyLazyEnumerator<E> grep(java.lang.String regex)
```
    Finds all elements which are matched by the regular expression.
    
    Specified by:
    
    grep in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    grep in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    regex - regular expression
    
    Returns:
    RubyLazyEnumerator
  - grep
```
public <S> RubyLazyEnumerator<S> grep(java.lang.String regex,
                             TransformBlock<? super E,? extends S> block)
```
    Finds all elements which are matched by the regular expression and transforms them.
    
    Specified by:
    
    grep in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    grep in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    regex - regular expression
    block - to transform elements
    
    Returns:
    RubyLazyEnumerator
  - grep
```
public <S> RubyLazyEnumerator<S> 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.
    
    Specified by:
    
    grep in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    grep in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    regex - regular expression
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyLazyEnumerator
  - groupBy
```
public RubyLazyEnumerator<E> groupBy()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    groupBy in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    groupBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - groupBy
```
public <S> RubyHash<S,RubyArray<E>> groupBy(TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Puts elements with the same result S returned by the block into a Entry<S, RubyArray<E>>y of a RubyHash.
    
    Specified by:
    
    groupBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to group each element
    
    Returns:
    RubyHash
  - groupBy
```
public <S> RubyHash<S,RubyArray<E>> groupBy(java.lang.String methodName,
                                   java.lang.Object... args)
```
    Description copied from interface: RubyContract.Enumerable
    
    Puts elements with the same result S invoked by given method name into a Entry<S, RubyArray<E>>y of a RubyHash.
    
    Specified by:
    
    groupBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyHash
  - includeʔ
```
public boolean includeʔ(E target)
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if target element is included.
    
    Specified by:
    
    includeʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    target - to be searched
    
    Returns:
    true if target is found,false otherwise
  - inject
```
public E inject(ReduceBlock<E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Assigns the first element as the initial value. Reduces each element with block, then assigns the result back to initial value and so on.
    
    Specified by:
    
    inject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to reduce each element
    
    Returns:
    element
  - inject
```
public <I> I inject(I init,
           WithInitBlock<? super E,I> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Reduces each element with block, then assigns the result back to initial value and so on.
    
    Specified by:
    
    inject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    block - to reduce each element
    
    Returns:
    object I
  - inject
```
public <I> I inject(I init,
           java.lang.String methodName)
```
    Description copied from interface: RubyContract.Enumerable
    
    Reduces each element with initial value by a method of S, then assigns the result back to initial value and so on.
    
    Specified by:
    
    inject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    I - the type of transformed elements
    Parameters:
    init - initial value
    methodName - method used to reduce elements
    
    Returns:
    object I
  - inject
```
public E inject(java.lang.String methodName)
```
    Description copied from interface: RubyContract.Enumerable
    
    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.
    
    Specified by:
    
    inject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    methodName - method used to reduce elements
    
    Returns:
    element
  - lazy
```
public RubyLazyEnumerator<E> lazy()
```
    Description copied from interface: RubyContract.Enumerable
    
    Returns a RubyLazyEnumerator.
    
    Specified by:
    
    lazy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - map
```
public RubyLazyEnumerator<E> map()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    map in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    map in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - map
```
public <S> RubyLazyEnumerator<S> map(TransformBlock<? super E,? extends S> block)
```
    Equivalent to RubyContract.Enumerable.collect(TransformBlock).
    
    Specified by:
    
    map in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    map in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyLazyEnumerator
  - map
```
public <S> RubyLazyEnumerator<S> map(java.lang.String methodName,
                            java.lang.Object... args)
```
    Equivalent to RubyContract.Enumerable.collect(String, Object...).
    
    Specified by:
    
    map in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    map in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyLazyEnumerator
  - max
```
public E max()
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the max element. Returns null if elements are empty.
    
    Specified by:
    
    max in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    element or null
  - max
```
public E max(java.util.Comparator<? super E> comp)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the max element compared by the Comparator. Returns null if elements are empty.
    
    Specified by:
    
    max in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    comp - a Comparator
    
    Returns:
    element or null
  - maxBy
```
public RubyLazyEnumerator<E> maxBy()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    maxBy in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    maxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - maxBy
```
public <S> E maxBy(java.util.Comparator<? super S> comp,
          TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the max element for outputs transformed by the block and compared by the Comparator. Returns null if elements are empty.
    
    Specified by:
    
    maxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    element or null
  - maxBy
```
public <S> E maxBy(TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the max element for outputs transformed by the block. Returns null if elements are empty.
    
    Specified by:
    
    maxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    element or null
  - maxBy
```
public <S> E maxBy(java.lang.String methodName,
          java.lang.Object... args)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the max element for outputs invoked by given method name. Returns null if elements are empty.
    
    Specified by:
    
    maxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    element or null
  - memberʔ
```
public boolean memberʔ(E target)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.includeʔ(Object).
    
    Specified by:
    
    memberʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    target - to be found
    
    Returns:
    element or null
  - min
```
public E min()
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min element. Returns null if elements are empty.
    
    Specified by:
    
    min in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    element or null
  - min
```
public E min(java.util.Comparator<? super E> comp)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min element for outputs compared by the Comparator. Returns null if elements are empty.
    
    Specified by:
    
    min in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    comp - a Comparator
    
    Returns:
    element or null
  - minBy
```
public RubyLazyEnumerator<E> minBy()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    minBy in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    minBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - minBy
```
public <S> E minBy(java.util.Comparator<? super S> comp,
          TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min element for outputs transformed by the block and compared by the Comparator. Returns null if elements are empty.
    
    Specified by:
    
    minBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    element or null
  - minBy
```
public <S> E minBy(TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min element for outputs transformed by the block. Returns null if elements are empty.
    
    Specified by:
    
    minBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    element or null
  - minBy
```
public <S> E minBy(java.lang.String methodName,
          java.lang.Object... args)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds min element for outputs invoked by given method name. Returns null if elements are empty.
    
    Specified by:
    
    minBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    element or null
  - minmax
```
public RubyArray<E> minmax()
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min and max elements.
    
    Specified by:
    
    minmax in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyArray
  - minmax
```
public RubyArray<E> minmax(java.util.Comparator<? super E> comp)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min and max elements for outputs compared by the Comparator.
    
    Specified by:
    
    minmax in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    comp - a Comparator
    
    Returns:
    RubyArray
  - minmaxBy
```
public RubyLazyEnumerator<E> minmaxBy()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    minmaxBy in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    minmaxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - minmaxBy
```
public <S> RubyArray<E> minmaxBy(java.util.Comparator<? super S> comp,
                        TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min and max elements for outputs transformed by the block and compared by the Comparator.
    
    Specified by:
    
    minmaxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    RubyArray
  - minmaxBy
```
public <S> RubyArray<E> minmaxBy(TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min and max elements for outputs transformed by the block.
    
    Specified by:
    
    minmaxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyArray
  - minmaxBy
```
public <S> RubyArray<E> minmaxBy(java.lang.String methodName,
                        java.lang.Object... args)
```
    Description copied from interface: RubyContract.Enumerable
    
    Finds the min and max elements for outputs invoked by given method name. Returns null if elements are empty.
    
    Specified by:
    
    minmaxBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyArray
  - noneʔ
```
public boolean noneʔ()
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if elements contain only null objects.
    
    Specified by:
    
    noneʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    true if all elements are null, false otherwise
  - noneʔ
```
public boolean noneʔ(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if elements contain only elements which are false returned by the block.
    
    Specified by:
    
    noneʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check elements
    
    Returns:
    true if all results of block are false, false otherwise
  - oneʔ
```
public boolean oneʔ()
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if elements contain only one element beside null.
    
    Specified by:
    
    oneʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    true if only one element beside null is found, false otherwise
  - oneʔ
```
public boolean oneʔ(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Checks if elements contain only one element which are true returned by the block.
    
    Specified by:
    
    oneʔ in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check elements
    
    Returns:
    true if only one result of block is true, false otherwise
  - partition
```
public RubyLazyEnumerator<E> partition()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    partition in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    partition in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - partition
```
public RubyArray<RubyArray<E>> partition(BooleanBlock<? super E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Divides elements into 2 groups by the given block.
    
    Specified by:
    
    partition in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to part elements
    
    Returns:
    RubyArray of 2 RubyArrays
  - reduce
```
public E reduce(ReduceBlock<E> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.inject(ReduceBlock).
    
    Specified by:
    
    reduce in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to reduce each element
    
    Returns:
    element
  - reduce
```
public <S> S reduce(S init,
           WithInitBlock<? super E,S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.inject(Object, WithInitBlock).
    
    Specified by:
    
    reduce in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    init - initial value
    block - to reduce each element
    
    Returns:
    object I
  - reduce
```
public <S> S reduce(S init,
           java.lang.String methodName)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.inject(Object, String).
    
    Specified by:
    
    reduce in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    init - initial value
    methodName - method used to reduce elements
    
    Returns:
    object I
  - reduce
```
public E reduce(java.lang.String methodName)
```
    Description copied from interface: RubyContract.Enumerable
    
    Equivalent to RubyContract.Enumerable.inject(String).
    
    Specified by:
    
    reduce in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    methodName - method used to reduce elements
    
    Returns:
    element
  - reject
```
public RubyLazyEnumerator<E> reject()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    reject in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    reject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - reject
```
public RubyLazyEnumerator<E> reject(BooleanBlock<? super E> block)
```
    Filters all elements which are true returned by the block.
    
    Specified by:
    
    reject in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    reject in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyLazyEnumerator
  - reverseEach
```
public RubyLazyEnumerator<E> reverseEach()
```
    Returns a reversed enumerator of elements.
    
    Specified by:
    
    reverseEach in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    reverseEach in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - reverseEach
```
public RubyLazyEnumerator<E> reverseEach(Block<? super E> block)
```
    Iterates each element reversely by given block.
    
    Specified by:
    
    reverseEach in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    reverseEach in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to yield each element
    
    Returns:
    RubyLazyEnumerator
  - select
```
public RubyLazyEnumerator<E> select()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    select in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    select in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - select
```
public RubyLazyEnumerator<E> select(BooleanBlock<? super E> block)
```
    Equivalent to RubyContract.Enumerable.findAll(BooleanBlock)
    
    Specified by:
    
    select in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    select in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyLazyEnumerator
  - sliceBefore
```
public RubyLazyEnumerator<RubyArray<E>> sliceBefore(BooleanBlock<? super E> block)
```
    Groups elements into RubyArrays and the first element of each RubyArray should get true returned by the block.
    
    Specified by:
    
    sliceBefore in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    sliceBefore in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to check where to do slice
    
    Returns:
    RubyLazyEnumerator
  - sliceBefore
```
public RubyLazyEnumerator<RubyArray<E>> sliceBefore(java.lang.String regex)
```
    Groups elements into RubyArrays and the first element of each RubyArray should be matched by the regex.
    
    Specified by:
    
    sliceBefore in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    sliceBefore in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    regex - to check where to do slice
    
    Returns:
    RubyLazyEnumerator
  - sort
```
public RubyArray<E> sort()
```
    Description copied from interface: RubyContract.Enumerable
    
    Sorts elements and puts them into a RubyArray.
    
    Specified by:
    
    sort in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyArray
  - sortBy
```
public RubyLazyEnumerator<E> sortBy()
```
    Returns an enumerator of elements.
    
    Specified by:
    
    sortBy in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    sortBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - sortBy
```
public <S> RubyArray<E> sortBy(java.util.Comparator<? super S> comp,
                      TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Sorts elements by the ordering of outputs transformed by the block induced by the Comparator, then puts them into a RubyArray.
    
    Specified by:
    
    sortBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    comp - a Comparator
    block - to transform elements
    
    Returns:
    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)
```
    Description copied from interface: RubyContract.Enumerable
    
    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.
    
    Specified by:
    
    sortBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    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
```
public <S> RubyArray<E> sortBy(TransformBlock<? super E,? extends S> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Sorts elements by the ordering of outputs transformed by the block, then puts them into a RubyArray.
    
    Specified by:
    
    sortBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Type Parameters:
    S - the type of transformed elements
    Parameters:
    block - to transform elements
    
    Returns:
    RubyArray
  - sortBy
```
public <S> RubyArray<E> sortBy(java.lang.String methodName,
                      java.lang.Object... args)
```
    Description copied from interface: RubyContract.Enumerable
    
    Sorts elements by the ordering of the outputs invoked by given method name, then puts them into a RubyArray.
    
    Specified by:
    
    sortBy in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    RubyArray
  - take
```
public RubyLazyEnumerator<E> take(int n)
```
    Takes the first n elements.
    
    Specified by:
    
    take in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    take in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    n - number of elements
    
    Returns:
    RubyLazyEnumerator
  - takeWhile
```
public RubyLazyEnumerator<E> takeWhile()
```
    Returns an enumerator which contains only the first element.
    
    Specified by:
    
    takeWhile in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    takeWhile in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyLazyEnumerator
  - takeWhile
```
public RubyLazyEnumerator<E> takeWhile(BooleanBlock<? super E> block)
```
    Takes elements until an element gets false returned by the block.
    
    Specified by:
    
    takeWhile in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    takeWhile in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    block - to filter elements
    
    Returns:
    RubyLazyEnumerator
  - toA
```
public RubyArray<E> toA()
```
    Description copied from interface: RubyContract.Enumerable
    
    Puts all elements into a RubyArray.
    
    Specified by:
    
    toA in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    RubyArray
  - zip
```
public RubyLazyEnumerator<RubyArray<E>> zip(java.lang.Iterable<? extends E>... others)
```
    Groups elements which get the same indices among all other Iterables into RubyArrays.
    
    Specified by:
    
    zip in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    zip in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    others - an array of Iterable
    
    Returns:
    RubyLazyEnumerator
  - zip
```
public RubyLazyEnumerator<RubyArray<E>> zip(java.util.List<? extends java.lang.Iterable<? extends E>> others)
```
    Groups elements which get the same indices among all other Lists into RubyArrays.
    
    Specified by:
    
    zip in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    zip in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    others - a List of Iterable
    
    Returns:
    RubyLazyEnumerator
  - zip
```
public void zip(java.util.List<? extends java.lang.Iterable<? extends E>> others,
       Block<? super RubyArray<E>> block)
```
    Description copied from interface: RubyContract.Enumerable
    
    Groups elements which get the same indices among all other Iterables into RubyArrays and yields them to the block.
    
    Specified by:
    
    zip in interface RubyContract.Enumerable<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Parameters:
    others - a List of Iterables
    block - to yield zipped elements
  - rewind
```
public RubyLazyEnumerator<E> rewind()
```
    Rewinds this Iterator to the beginning.
    
    Specified by:
    
    rewind in interface Ruby.LazyEnumerator<E>
    
    Specified by:
    
    rewind in interface RubyContract.Enumerator<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    this RubyLazyEnumerator
  - peek
```
public E peek()
```
    Description copied from interface: RubyContract.Enumerator
    
    Returns the next element without advancing the iteration.
    
    Specified by:
    
    peek in interface RubyContract.Enumerator<E,Ruby.LazyEnumerator<?>,Ruby.LazyEnumerator<?>>
    
    Returns:
    element
  - iterator
```
public java.util.Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<E>
  - hasNext
```
public boolean hasNext()
```
    Specified by:
    
    hasNext in interface java.util.Iterator<E>
  - next
```
public E next()
```
    Specified by:
    
    next in interface java.util.Iterator<E>
  - remove
```
public void remove()
```
    Specified by:
    
    remove in interface java.util.Iterator<E>
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class RubyLazyEnumerator<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RubyLazyEnumerator

Method Detail

of

copyOf

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

findAll

find

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