Class: Enumerator::Product
Relationships & Source Files | |
Super Chains via Extension / Inclusion / Inheritance | |
Class Chain:
self,
::Enumerator
|
|
Instance Chain:
self,
::Enumerator ,
::Enumerable
|
|
Inherits: |
Enumerator
|
Defined in: | enumerator.c, enumerator.c |
Overview
Product
generates a Cartesian product of any number of enumerable objects. Iterating over the product of enumerable objects is roughly equivalent to nested each_entry loops where the loop for the rightmost object is put innermost.
innings = Enumerator::Product.new(1..9, ['top', 'bottom'])
innings.each do |i, h|
p [i, h]
end
# [1, "top"]
# [1, "bottom"]
# [2, "top"]
# [2, "bottom"]
# [3, "top"]
# [3, "bottom"]
# ...
# [9, "top"]
# [9, "bottom"]
The method used against each enumerable object is each_entry
instead of #each so that the product of N enumerable objects yields an array of exactly N elements in each iteration.
When no enumerator is given, it calls a given block once yielding an empty argument list.
This type of objects can be created by product.
Class Method Summary
-
.new(*enums) ⇒ Enumerator
constructor
Generates a new enumerator object that generates a Cartesian product of given enumerable objects.
::Enumerator
- Inherited
.new | Creates a new |
.produce | Creates an infinite enumerator from any block, just called over and over. |
.product | Generates a new enumerator object that generates a Cartesian product of given enumerable objects. |
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 |
#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 |
#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 |
#with_index | Iterates the given block for each element with an index, which starts from |
#with_object | Iterates the given block for each element with an arbitrary object, |
#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- |
#count | Returns the count of elements, based on an argument or block criterion, if given. |
#cycle | When called with positive integer argument |
#detect | Alias for Enumerable#find. |
#drop | For positive integer |
#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 |
#each_entry | Calls the given block with each element, converting multiple values from yield to an array; returns |
#each_slice | Calls the block with each successive disjoint |
#each_with_index | Invoke |
#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 |
#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 |
#grep_v | Returns an array of objects based on elements of |
#group_by | With a block given returns a hash: |
#include? | Alias for Enumerable#member?. |
#inject | Returns the result of applying a reducer to an initial value and the first element of the |
#lazy | Returns an |
#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 |
#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 |
#select | Alias for Enumerable#filter. |
#slice_after | Creates an enumerator for each chunked elements. |
#slice_before | With argument |
#slice_when | Creates an enumerator for each chunked elements. |
#sort | Returns an array containing the sorted elements of |
#sort_by | With a block given, returns an array of elements of |
#sum | With no block given, returns the sum of |
#take | For non-negative integer |
#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 | When argument |
#to_a | Returns an array containing the items in |
#to_h | When |
#to_set | Makes a set from the enumerable object with given arguments. |
#uniq | With no block, returns a new array containing only unique elements; the array has no two elements |
#zip | With no block given, returns a new array |
Constructor Details
.new(*enums) ⇒ Enumerator
Generates a new enumerator object that generates a Cartesian product of given enumerable objects.
e = Enumerator::Product.new(1..3, [4, 5])
e.to_a #=> [[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]
e.size #=> 6
# File 'enumerator.c', line 3494
static VALUE enum_product_initialize(int argc, VALUE *argv, VALUE obj) { struct enum_product *ptr; VALUE enums = Qnil, options = Qnil; rb_scan_args(argc, argv, "*:", &enums, &options); if (!NIL_P(options) && !RHASH_EMPTY_P(options)) { rb_exc_raise(rb_keyword_error_new("unknown", rb_hash_keys(options))); } rb_check_frozen(obj); TypedData_Get_Struct(obj, struct enum_product, &enum_product_data_type, ptr); if (!ptr) rb_raise(rb_eArgError, "unallocated product"); ptr->enums = rb_ary_freeze(enums); return obj; }