Class: Enumerator::Chain

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `::Enumerator`
Instance Chain: self, `::Enumerator`, `::Enumerable`
Inherits:	Enumerator `::Object` Enumerator Enumerator::Chain
Defined in:	enumerator.c, enumerator.c

Overview

Chain is a subclass of ::Enumerator, which represents a chain of enumerables that works as a single enumerator.

This type of objects can be created by Enumerable#chain and #+.

Class Method Summary

.new(*enums) ⇒ Enumerator constructor

Generates a new enumerator object that iterates over the elements of given enumerable objects in sequence.

`::Enumerator` - Inherited

.new	Creates a new `::Enumerator` object, which can be used as an `::Enumerable`.
.produce	Creates an infinite enumerator from any block, just called over and over.

Instance Method Summary

`::Enumerator` - Inherited

#+	Returns an enumerator object generated from this enumerator and a given enumerable.
#each	Iterates over the block according to how this `::Enumerator` was constructed.
#each_with_index	Same as #with_index(0), i.e. there is no starting offset.
#each_with_object	Alias for #with_object.
#feed	Sets the value to be returned by the next yield inside `e`.
#inspect	Creates a printable version of e.
#next	Returns the next object in the enumerator, and move the internal position forward.
#next_values	Returns the next object as an array in the enumerator, and move the internal position forward.
#peek	Returns the next object in the enumerator, but doesn’t move the internal position forward.
#peek_values	Returns the next object as an array, similar to #next_values, but doesn’t move the internal position forward.
#rewind	Rewinds the enumeration sequence to the beginning.
#size	Returns the size of the enumerator, or `nil` if it can’t be calculated lazily.
#with_index	Iterates the given block for each element with an index, which starts from `offset`.
#with_object	Iterates the given block for each element with an arbitrary object, `obj`, and returns `obj`
#initialize_copy

`::Enumerable` - Included

#all?	Returns whether every element meets a given criterion.
#any?	Returns whether any element meets a given criterion.
#chain	Returns an enumerator object generated from this enumerator and given enumerables.
#chunk	Each element in the returned enumerator is a 2-element array consisting of:
#chunk_while	Creates an enumerator for each chunked elements.
#collect	Alias for Enumerable#map.
#collect_concat	Alias for Enumerable#flat_map.
#compact	Returns an array of all non-`nil` elements:
#count	Returns the count of elements, based on an argument or block criterion, if given.
#cycle	When called with positive integer argument `n` and a block, calls the block with each element, then does so again, until it has done so `n` times; returns `nil`:
#detect	Alias for Enumerable#find.
#drop	For positive integer `n`, returns an array containing all but the first `n` elements:
#drop_while	Calls the block with successive elements as long as the block returns a truthy value; returns an array of all elements after that point:
#each_cons	Calls the block with each successive overlapped `n`-tuple of elements; returns `self`:
#each_entry	Calls the given block with each element, converting multiple values from yield to an array; returns `self`:
#each_slice	Calls the block with each successive disjoint `n`-tuple of elements; returns `self`:
#each_with_index	With a block given, calls the block with each element and its index; returns `self`:
#each_with_object	Calls the block once for each element, passing both the element and the given object:
#entries	Alias for Enumerable#to_a.
#filter	Returns an array containing elements selected by the block.
#filter_map	Returns an array containing truthy elements returned by the block.
#find	Returns the first element for which the block returns a truthy value.
#find_all	Alias for Enumerable#filter.
#find_index	Returns the index of the first element that meets a specified criterion, or `nil` if no such element is found.
#first	Returns the first element or elements.
#flat_map	Returns an array of flattened objects returned by the block.
#grep	Returns an array of objects based elements of `self` that match the given pattern.
#grep_v	Returns an array of objects based on elements of `self` that don’t match the given pattern.
#group_by	With a block given returns a hash:
#include?	Alias for Enumerable#member?.
#inject	Returns an object formed from operands via either:
#lazy	Returns an `Lazy`, which redefines most `::Enumerable` methods to postpone enumeration and enumerate values only on an as-needed basis.
#map	Returns an array of objects returned by the block.
#max	Returns the element with the maximum element according to a given criterion.
#max_by	Returns the elements for which the block returns the maximum values.
#member?	Returns whether for any element `object == element`:
#min	Returns the element with the minimum element according to a given criterion.
#min_by	Returns the elements for which the block returns the minimum values.
#minmax	Returns a 2-element array containing the minimum and maximum elements according to a given criterion.
#minmax_by	Returns a 2-element array containing the elements for which the block returns minimum and maximum values:
#none?	Returns whether no element meets a given criterion.
#one?	Returns whether exactly one element meets a given criterion.
#partition	With a block given, returns an array of two arrays:
#reduce	Alias for Enumerable#inject.
#reject	Returns an array of objects rejected by the block.
#reverse_each	With a block given, calls the block with each element, but in reverse order; returns `self`:
#select	Alias for Enumerable#filter.
#slice_after	Creates an enumerator for each chunked elements.
#slice_before	With argument `pattern`, returns an enumerator that uses the pattern to partition elements into arrays (“slices”).
#slice_when	Creates an enumerator for each chunked elements.
#sort	Returns an array containing the sorted elements of `self`.
#sort_by	With a block given, returns an array of elements of `self`, sorted according to the value returned by the block for each element.
#sum	With no block given, returns the sum of `initial_value` and the elements:
#take	For non-negative integer `n`, returns the first `n` elements:
#take_while	Calls the block with successive elements as long as the block returns a truthy value; returns an array of all elements up to that point:
#tally	Returns a hash containing the counts of equal elements:
#to_a	Returns an array containing the items in `self`:
#to_h	When `self` consists of 2-element arrays, returns a hash each of whose entries is the key-value pair formed from one of those arrays:
#uniq	With no block, returns a new array containing only unique elements; the array has no two elements `e0` and `e1` such that `e0.eql?(e1)`:
#zip	With no block given, returns a new array `new_array` of size self.size whose elements are arrays.

Constructor Details

.new(*enums) ⇒ Enumerator

Generates a new enumerator object that iterates over the elements of given enumerable objects in sequence.

e = Enumerator::Chain.new(1..3, [4, 5])
e.to_a #=> [1, 2, 3, 4, 5]
e.size #=> 5

[ GitHub ]

# File 'enumerator.c', line 3131


static VALUE
enum_chain_initialize(VALUE obj, VALUE enums)
{
    struct enum_chain *ptr;

    rb_check_frozen(obj);
    TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);

    if (!ptr) rb_raise(rb_eArgError, "unallocated chain");

    ptr->enums = rb_obj_freeze(enums);
    ptr->pos = -1;

    return obj;
}

Class: Enumerator::Chain

Overview

Class Method Summary

::Enumerator - Inherited

Instance Method Summary

::Enumerator - Inherited

::Enumerable - Included

Constructor Details

.new(*enums) ⇒ Enumerator

`::Enumerator` - Inherited

`::Enumerator` - Inherited

`::Enumerable` - Included