ライブラリ:ビルトイン > バージョン:2.7.0 > クエリ:_builtin > クエリ:Enumerable

245件ヒット [101-200件を表示] （0.284秒）

トップページ >

:ビルトイン

:2.7.0

:_builtin

:Enumerable

別のキーワード

種類

クラス

モジュール

Enumerable (122)

オブジェクト

ENV (2)
main (1)

キーワード

+ (1)
== (1)
=== (2)
Chain (1)
Enumerator (1)
Lazy (1)
Range (1)
all? (6)
any? (6)
chain (1)
chunk (3)
chunk_while (2)
collect (5)
collect_concat (3)
count (6)
cycle (2)
detect (2)
drop (3)
drop_while (5)
each_cons (2)
each_entry (2)
each_slice (2)
each_with_index (2)
each_with_object (2)
entries (1)
enum_for (4)
filter (7)
filter_map (3)
find (2)
find_all (3)
find_index (3)
first (2)
flat_map (3)
force (1)
grep (3)
grep_v (3)
group_by (2)
hash (1)
include (2)
include? (1)
inject (3)
lazy (1)
map (5)
max (12)
max_by (4)
member? (1)
min (12)
min_by (4)
minmax (4)
minmax_by (2)
new (2)
none? (6)
one? (6)
partition (2)
prepended (1)
produce (1)
reduce (3)
reject (9)
reverse_each (2)
select (7)
slice_after (4)
slice_before (5)
slice_when (2)
sort (4)
sort! (2)
sort_by (2)
sort_by! (2)
sum (4)
take (3)
take_while (6)
tally (1)
to_a (1)
to_enum (4)
to_h (4)
uniq (4)
with_object (2)
zip (4)

検索結果

<< < 1 2 3 > >>

Enumerable#max {|a, b| ... } -> object | nil (87007.0)

2.7.0

インスタンスメソッド

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最大の n 要素が入った降順の配列を返します。引数を指定しない形式では要素が存在しなければ nil を返します。引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最大の
n 要素が入った降順の配列を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、
a == b のとき 0、a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

@raise TypeError ブロックが整数以外を返したときに発生します。

//emlist[例][ruby]{
class Person
...

Enumerable#max(n) -> Array (87007.0)

2.7.0

インスタンスメソッド

最大の要素、もしくは最大の n 要素が入った降順の配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

最大の要素、もしくは最大の n 要素が入った降順の配列を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

//emlist[例][ruby]{
a = %w(albatross dog horse)
a.max # => "horse"
a.max(2) # =>...

Enumerable#max(n) {|a, b| ... } -> Array (87007.0)

2.7.0

インスタンスメソッド

Enumerable#member?(val) -> bool (87007.0)

2.7.0

インスタンスメソッド

val と == の関係にある要素を含むとき真を返します。

val と == の関係にある要素を含むとき真を返します。

@param val 任意のオブジェクト

//emlist[例][ruby]{
[2, 4, 6].include? 2 #=> true
[2, 4, 6].include? 1 #=> false
[2, 4, 6].member? 2 #=> true
[2, 4, 6].member? 1 #=> false
//}

Enumerable#min -> object | nil (87007.0)

2.7.0

インスタンスメソッド

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

//emlist[例][ruby]{
a = %w(albatross dog horse)
a.min # => "albatross"
a.min(2) ...

絞り込み条件を変える

Enumerable#min {|a, b| ... } -> object | nil (87007.0)

2.7.0

インスタンスメソッド

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。引数を指定しない形式では要素が存在しなければ nil を返します。引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の
n 要素が昇順で入った配列を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、
a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

@param n 取得する要素数。

//emlist[例][ruby]{
class Person
attr_reader :name, :age

def initialize...

Enumerable#min(n) -> Array (87007.0)

2.7.0

インスタンスメソッド

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

Enumerable#min(n) {|a, b| ... } -> Array (87007.0)

2.7.0

インスタンスメソッド

Enumerable#partition -> Enumerator (87007.0)

2.7.0

インスタンスメソッド

各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。各要素に対してブロックを評価して、その値が真であった要素の配列と、偽であった要素の配列の 2 つを配列に入れて返します。

各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。
各要素に対してブロックを評価して、その値が真であった要素の配列と、
偽であった要素の配列の 2 つを配列に入れて返します。

ブロックを省略した場合は Enumerator を返します。

//emlist[例][ruby]{
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition {|i| i % 3 == 0 }
#=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]
//}

Enumerable#partition {|item| ... } -> [[object], [object]] (87007.0)

2.7.0

インスタンスメソッド

絞り込み条件を変える

Enumerable#reduce(init = self.first) {|result, item| ... } -> object (87007.0)

2.7.0

インスタンスメソッド

リストのたたみこみ演算を行います。

リストのたたみこみ演算を行います。

最初に初期値 init と self の最初の要素を引数にブロックを実行します。
2 回目以降のループでは、前のブロックの実行結果と
self の次の要素を引数に順次ブロックを実行します。
そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。

要素が存在しない場合は init を返します。

初期値 init を省略した場合は、
最初に先頭の要素と 2 番目の要素をブロックに渡します。
また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。
要素がなければブロックを実行せずに nil を返します。

@param in...

Enumerable#reduce(init, sym) -> object (87007.0)

2.7.0

インスタンスメソッド

リストのたたみこみ演算を行います。

Enumerable#reduce(sym) -> object (87007.0)

2.7.0

インスタンスメソッド

リストのたたみこみ演算を行います。

Enumerable#reverse_each -> Enumerator (87007.0)

2.7.0

インスタンスメソッド

逆順に各要素に対してブロックを評価します。

逆順に各要素に対してブロックを評価します。

内部で各要素を保持した配列を作ります。

ブロックを省略した場合は、各要素を逆順に辿る
Enumerator を返します。

//emlist[例][ruby]{
(1..3).reverse_each # => #<Enumerator: 1..3:reverse_each>
(1..3).reverse_each { |v| p v }
# => 3
# 2
# 1
//}

Enumerable#reverse_each {|element| ... } -> self (87007.0)

2.7.0

インスタンスメソッド

逆順に各要素に対してブロックを評価します。

絞り込み条件を変える

Enumerable#tally -> Hash (87007.0)

2.7.0

インスタンスメソッド

self に含まれる要素を数え上げた結果を Hash で返します。 Hash のキーは self に含まれる要素で、Hash の値は対応する要素が出現する回数です。

self に含まれる要素を数え上げた結果を Hash で返します。
Hash のキーは self に含まれる要素で、Hash の値は対応する要素が出現する回数です。

返り値は Hash であり、内部でも Hash と同等に要素を区別し数えます。
そのため、独自で定義するクラスでも Object#hash と Object#eql? を適切に定義することで数えることができます。

//emlist[例][ruby]{
["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1}

//}

Enumerable#to_a(*args) -> [object] (87007.0)

2.7.0

インスタンスメソッド

全ての要素を含む配列を返します。

全ての要素を含む配列を返します。

@param args each の呼び出し時に引数として渡されます。

//emlist[例][ruby]{
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]

require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
//}

Enumerable#to_h(*args) -> Hash (87007.0)

2.7.0

インスタンスメソッド

self を [key, value] のペアの配列として解析した結果を Hash にして返します。

self を [key, value] のペアの配列として解析した結果を Hash にして
返します。

@param args each の呼び出し時に引数として渡されます。

//emlist[例][ruby]{
%i[hello world].each_with_index.to_h # => {:hello => 0, :world => 1}
//}

ブロックを指定すると各要素でブロックを呼び出し、
その結果をペアとして使います。

//emlist[ブロック付きの例][ruby]{
(1..5).to_h {|x| [x, x ** 2]} # => {1=>1, 2=>4, ...

Enumerable#to_h(*args) { ... } -> Hash (87007.0)

2.7.0

インスタンスメソッド

self を [key, value] のペアの配列として解析した結果を Hash にして返します。

Enumerable#uniq -> Array (87007.0)

2.7.0

インスタンスメソッド

self から重複した値を取り除いた配列を返します。

self から重複した値を取り除いた配列を返します。

ブロックが与えられた場合、ブロックが返した値が重複した要素を取り除いた
配列を返します。

//emlist[例][ruby]{
olympics = {
1896 => 'Athens',
1900 => 'Paris',
1904 => 'Chicago',
1906 => 'Athens',
1908 => 'Rome',
}
olympics.uniq{|k,v| v} # => [[1896, "Athens"], [1900, "Paris"], [1904, "Chicago"], [1908, "Ro...

絞り込み条件を変える

Enumerable#uniq { |item| ... } -> Array (87007.0)

2.7.0

インスタンスメソッド

self から重複した値を取り除いた配列を返します。

Enumerable#zip(*lists) -> [[object]] (87007.0)

2.7.0

インスタンスメソッド

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。生成される配列の要素数は self の要素数と同じです。

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。
生成される配列の要素数は self の要素数と同じです。

ブロック付きで呼び出した場合は、
self と引数に渡した配列の各要素を順番にブロックに渡します。

@param lists 配列を指定します。配列でない場合は to_ary メソッドにより配列に変換します。
to_ary メソッドが無い場合は each を試します。

//emlist[例][ruby]{
p (1..3).zip([4,5,6], [7,8,9])
# => [[1, 4, 7], [2, 5, 8], [3,...

Enumerable#zip(*lists) {|v1, v2, ...| ...} -> nil (87007.0)

2.7.0

インスタンスメソッド

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。生成される配列の要素数は self の要素数と同じです。

Enumerator.produce(initial = nil) { |prev| ... } -> Enumerator (24097.0)

2.7.0

特異メソッド

与えられたブロックを呼び出し続ける、停止しない Enumerator を返します。
ブロックの戻り値が、次にブロックを呼び出す時に引数として渡されます。
initial 引数が渡された場合、最初にブロックを呼び出す時にそれがブロック
呼び出しの引数として渡されます。initial が渡されなかった場合は nil が
渡されます。

ブロックが例外 StopIterationを投げた場合、繰り返しが終了します。

@param initial ブロックに最初に渡される値です。任意のオブジェクトを渡せます。

//emlist[例][ruby]{
# 1, 2, 3, 4, ... と続く En...

Enumerator (24091.0)

2.7.0

クラス

each 以外のメソッドにも Enumerable の機能を提供するためのラッパークラスです。また、外部イテレータとしても使えます。

each 以外のメソッドにも Enumerable の機能を提供するためのラッパークラスです。
また、外部イテレータとしても使えます。

Enumerable モジュールは、 Module#include 先のクラスが持つ
each メソッドを元に様々なメソッドを提供します。
例えば Array#map は Array#each の繰り返しを元にして定義されます。
Enumerator を介することにより String#each_byte のような
異なる名前のイテレータについても each と同様に Enumerable の機能を利用できます。

Enumerator を生成するには Enu...

絞り込み条件を変える

Enumerator::ArithmeticSequence#==(other) -> bool (24091.0)

2.7.0

インスタンスメソッド

Enumerable::ArithmeticSequence として等しいか判定します。

Enumerable::ArithmeticSequence として等しいか判定します。

other が Enumerable::ArithmeticSequence で
begin, end, step, exclude_end? が等しい時に
true を返します。

@param other 自身と比較する Enumerable::ArithmeticSequence

Enumerator::Lazy#grep(pattern) {|item| ... } -> Enumerator::Lazy (24091.0)

2.7.0

インスタンスメソッド

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep(/\A(\d)\1+\z/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)....

Enumerator::Lazy#grep_v(pattern) {|item| ... } -> Enumerator::Lazy (24091.0)

2.7.0

インスタンスメソッド

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep_v(/(\d).*\1/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/).t...

Enumerator::Lazy#take(n) -> Enumerator::Lazy (24091.0)

2.7.0

インスタンスメソッド

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

n が大きな数 (100000とか) の場合に備えて再定義されています。
配列が必要な場合は Enumerable#first を使って下さい。

@param n 要素数を指定します。

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.take(5)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:...

Enumerator::Lazy#zip(*lists) -> Enumerator::Lazy (24091.0)

2.7.0

インスタンスメソッド

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

ただし一貫性のため、ブロック付きで呼び出した場合は Enumerable#zip と
同じ挙動になります。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>

1.step.lazy.zip(('a'..'z').cycle)...

絞り込み条件を変える

Enumerator::Lazy#zip(*lists) {|v1, v2, ...| ... } -> nil (24091.0)

2.7.0

インスタンスメソッド

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.chunk{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f8bf18118f0>:each>>

1.step.lazy.chunk{ |n| n % 3 == 0 }.take(5).force
# => [[false, [1, 2]], [true, [3]], [false, [4, 5...

Enumerator::Lazy#chunk(initial_state) {|elt, state| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#collect {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.map{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:map>

1.step.lazy.collect{ |n| n.succ }.take(10).force
# => [2, 3, 4, 5, 6, 7, 8,...

Enumerator::Lazy#drop(n) -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

@param n 要素数を指定します。

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.drop(3)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop(3)>

1.step.lazy.drop(3).take(10).force
# => [4, 5, 6, 7, 8, 9, 10, 1...

絞り込み条件を変える

Enumerator::Lazy#drop_while {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.drop_while { |i| i < 42 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop_while>

1.step.lazy.drop_while { |i| i < 42 }.take(10).force
# => [42, 43, 44, 45, 46, 47, 48, 49, 50, 51]
//...

Enumerator::Lazy#filter {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.find_all { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:find_all>

1.step.lazy.select { |i| i.even? }.take(10).force
# => [2, 4, 6,...

Enumerator::Lazy#filter_map {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#filter_map と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#filter_map と同じですが、配列ではなく Enumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.filter_map { |n| n * 2 if n.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: (1.step)>:filter_map>

1.step.lazy.filter_map { |n| n * 2 if n.even? }.take(10).fo...

Enumerator::Lazy#find_all {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#map {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

絞り込み条件を変える

Enumerator::Lazy#reject {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.reject { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:reject>

1.step.lazy.reject { |i| i.even? }.take(10).force
# => [1, 3, 5, 7, ...

Enumerator::Lazy#select {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_after { |e| e % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007fd73980e6f8>:each>>

1.step.lazy.slice_after { |e| e % 3 == 0 }.take(5).force
# => [[1, 2, 3], [4, 5, 6], [...

Enumerator::Lazy#slice_after(pattern) -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_before { |e| e.even? }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007f9f31844ce8>:each>>

1.step.lazy.slice_before { |e| e % 3 == 0 }.take(5).force
# => [[1, 2], [3, 4, 5], [6...

絞り込み条件を変える

Enumerator::Lazy#slice_before(initial_state) {|elt, state| bool } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_before(pattern) -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007fce84118348>:each>>

1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }.take(5).force
# => [[1, 2]...

Enumerator::Lazy#take_while -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle).take_while { |e| e.first < 100_000 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>:take_while>

1.step.lazy....

Enumerator::Lazy#take_while {|item| ... } -> Enumerator::Lazy (24073.0)

2.7.0

インスタンスメソッド

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

絞り込み条件を変える

ENV.reject -> Enumerator (24055.0)

2.7.0

特異メソッド

環境変数のうち、ブロックを評価した値が真であるものをとり除きます。 Enumerable#reject と異なり Hash を返します。また、とり除いた結果は実際の環境変数に影響を与えません。

環境変数のうち、ブロックを評価した値が真であるものをとり除きます。
Enumerable#reject と異なり Hash を返します。また、とり除いた結果
は実際の環境変数に影響を与えません。

//emlist[][ruby]{
ENV['TEST'] = 'foo'
result = ENV.reject { |key, value| key == 'TEST' }
result['TEST'] # => nil
ENV['TEST'] # => "foo"
//}

ENV.reject {|key, value| ... } -> Hash (24055.0)

2.7.0

特異メソッド

Enumerator::Chain.new(*enums) -> Enumerator::Chain (24055.0)

2.7.0

特異メソッド

複数の Enumerable から、1つの新しい Enumerator を作って返します。

複数の Enumerable から、1つの新しい Enumerator を作って返します。

//emlist[例][ruby]{
e = Enumerator::Chain.new(1..3, [4, 5])
e.to_a #=> [1, 2, 3, 4, 5]
e.size #=> 5
//}

Enumerator::Lazy#chunk_while {|elt_before, elt_after| ... } -> Enumerator::Lazy (24055.0)

2.7.0

インスタンスメソッド

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

Enumerator::Lazy#uniq -> Enumerator::Lazy (24055.0)

2.7.0

インスタンスメソッド

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

絞り込み条件を変える

Enumerator::Lazy#uniq {|item| ... } -> Enumerator::Lazy (24055.0)

2.7.0

インスタンスメソッド

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Array#collect -> Enumerator (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した結果を全て含む配列を返します。

各要素に対してブロックを評価した結果を全て含む配列を返します。

ブロックを省略した場合は Enumerator を返します。

//emlist[例][ruby]{
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]
//}

@see Hash#to_h, Enumerable#collect, Enumerable#map

Array#collect {|item| ... } -> [object] (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した結果を全て含む配列を返します。

Array#map -> Enumerator (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した結果を全て含む配列を返します。

Array#map {|item| ... } -> [object] (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した結果を全て含む配列を返します。

絞り込み条件を変える

Array#reject -> Enumerator (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価し、その値が偽であった要素を集めた新しい配列を返します。条件を反転させた select です。

各要素に対してブロックを評価し、
その値が偽であった要素を集めた新しい配列を返します。
条件を反転させた select です。

ブロックを省略した場合は Enumerator を返します。

//emlist[例][ruby]{
# 偶数を除外する (奇数を集める)
[1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 } # => [1, 3, 5]
//}

@see Array#select, Enumerable#reject
@see Enumerable#grep_v

Array#reject {|item| ... } -> [object] (24043.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価し、その値が偽であった要素を集めた新しい配列を返します。条件を反転させた select です。

Enumerator::Lazy (24043.0)

2.7.0

クラス

map や select などのメソッドの遅延評価版を提供するためのクラス。

map や select などのメソッドの遅延評価版を提供するためのクラス。

動作は通常の Enumerator と同じですが、以下のメソッドが遅延評価を行う
(つまり、配列ではなく Enumerator を返す) ように再定義されています。

* map/collect
* flat_map/collect_concat
* filter_map
* select/find_all
* reject
* grep, grep_v
* take, take_while
* drop, drop_while
* slice_before, slice_after, slice...

Enumerator::Lazy.new(obj, size=nil) {|yielder, *values| ... } -> Enumerator::Lazy (24043.0)

2.7.0

特異メソッド

Lazy Enumerator を作成します。Enumerator::Lazy#force メソッドなどによって列挙が実行されたとき、objのeachメソッドが実行され、値が一つずつブロックに渡されます。ブロックは、yielder を使って最終的に yield される値を指定できます。

Lazy Enumerator を作成します。Enumerator::Lazy#force メソッドなどに
よって列挙が実行されたとき、objのeachメソッドが実行され、値が一つずつ
ブロックに渡されます。ブロックは、yielder を使って最終的に yield される値を
指定できます。

//emlist[Enumerable#filter_map と、その遅延評価版を定義する例][ruby]{
module Enumerable
def filter_map(&block)
map(&block).compact
end
end

class Enumerator::...

Hash#reject -> Enumerator (24043.0)

2.7.0

インスタンスメソッド

self を複製して、ブロックを評価した値が真になる要素を削除したハッシュを返します。

self を複製して、ブロックを評価した値が真になる要
素を削除したハッシュを返します。

ハッシュを返すことを除けば
Enumerable#reject とほぼ同じです。
selfを破壊的に変更したい場合はかわりにHash#delete_ifかHash#reject!を使います。

//emlist[例][ruby]{
h = { 2 =>"8" ,4 =>"6" ,6 =>"4" ,8 =>"2" }

p h.reject{|key, value| key.to_i < value.to_i} #=> {6=>"4", 8=>"2"}
//}

@see Hash#delete_if,...

絞り込み条件を変える

Hash#reject {|key, value| ... } -> Hash (24043.0)

2.7.0

インスタンスメソッド

self を複製して、ブロックを評価した値が真になる要素を削除したハッシュを返します。

Module#prepended(class_or_module) -> () (24043.0)

2.7.0

インスタンスメソッド

self が Module#prepend されたときに対象のクラスまたはモジュールを引数にしてインタプリタがこのメソッドを呼び出します。

self が Module#prepend されたときに対象のクラスまたはモジュールを
引数にしてインタプリタがこのメソッドを呼び出します。

@param class_or_module Module#prepend を実行したオブジェクト

//emlist[例][ruby]{
module A
def self.prepended(mod)
puts "#{self} prepended to #{mod}"
end
end
module Enumerable
prepend A
end
# => "A prepended to Enumerable"
//}

@...

Object#===(other) -> bool (24043.0)

2.7.0

インスタンスメソッド

case 式で使用されるメソッドです。d:spec/control#case も参照してください。

case 式で使用されるメソッドです。d:spec/control#case も参照してください。

このメソッドは case 式での振る舞いを考慮して、
各クラスの性質に合わせて再定義すべきです。

デフォルトでは内部で Object#== を呼び出します。

when 節の式をレシーバーとして === を呼び出すことに注意してください。

また Enumerable#grep でも使用されます。

@param other 比較するオブジェクトです。

//emlist[][ruby]{
age = 12
# (0..2).===(12), (3..6).===(12), ... が実行...

Range (24043.0)

2.7.0

クラス

範囲オブジェクトのクラス。範囲オブジェクトは文字どおり何らかの意味での範囲を表します。数の範囲はもちろん、日付の範囲や、「"a" から "z" まで」といった文字列の範囲を表すこともできます。

...(1, nil) # 1 以上（上限無し）を表す
p(1..nil) # 同上
p(1..) # 同上（略した書き方）
//}

また、Ruby 2.7.0 では始端に nil を与えることで「始端を持たない範囲オブジェクト」
を作ることもできるようになりました...

Array#max -> object | nil (24028.0)

2.7.0

インスタンスメソッド

最大の要素、もしくは最大の n 要素が降順に入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

最大の要素、もしくは最大の n 要素が降順に入った配列を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

//emlist[例][ruby]{
[].max #=> nil
[].max(1) #=> []
[2, 5, 3].max #=> 5
[2, 5, 3].max(2) #=> [5, 3]
//}

@param n 取得する要素数。

@see Enumerable#max

絞り込み条件を変える

Array#max {|a, b| ... } -> object | nil (24028.0)

2.7.0

インスタンスメソッド

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最大の n 要素が降順に入った配列を返します。引数を指定しない形式では要素が存在しなければ nil を返します。引数を指定する形式では、空の配列を返します。

ブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最大の
n 要素が降順に入った配列を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、
a == b のとき 0、a < b のとき負の整数を、期待しています。

//emlist[例][ruby]{
[].max {|a, b| a <=> b } #=> nil
[].max(1) {|a, b| a <=> b } #=> []

ary = %w(albatross dog horse)
ary.ma...

Array#max(n) -> Array (24028.0)

2.7.0

インスタンスメソッド

最大の要素、もしくは最大の n 要素が降順に入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

Array#max(n) {|a, b| ... } -> Array (24028.0)

2.7.0

インスタンスメソッド

Array#min -> object | nil (24028.0)

2.7.0

インスタンスメソッド

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。
全要素が互いに <=> メソッドで比較できることを仮定しています。

引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

//emlist[例][ruby]{
[].min #=> nil
[].min(1) #=> []
[2, 5, 3].min #=> 2
[2, 5, 3].min(2) #=> [2, 3]
//}

@param n 取得する要素数。

@see Enumerable#min

Array#min {|a, b| ... } -> object | nil (24028.0)

2.7.0

インスタンスメソッド

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の
n 要素が昇順で入った配列を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、
a < b のとき負の整数を、期待しています。

//emlist[例][ruby]{
[].min {|a, b| a <=> b } #=> nil
[].min(1) {|a, b| a <=> b } #=> []

ary = %w(albatross dog horse)
ary.mi...

絞り込み条件を変える

Array#min(n) -> Array (24028.0)

2.7.0

インスタンスメソッド

最小の要素、もしくは最小の n 要素が昇順で入った配列を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

Array#min(n) {|a, b| ... } -> Array (24028.0)

2.7.0

インスタンスメソッド

ブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の
n 要素が昇順で入った配列を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。
引数を指定する形式では、空の配列を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、
a < b のとき負の整数を、期待しています。

//emlist[例][ruby]{
[].min {|a, b| a <=> b } #=> nil
[].min(1) {|a, b| a <=> b } #=> []

ary = %w(albatross dog horse)
ary.mi...

Array#all? -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が真である場合に true を返します。偽である要素があれば、ただちに false を返します。

すべての要素が真である場合に true を返します。
偽である要素があれば、ただちに false を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果
が真である場合に true を返します。ブロックが偽を返した時点で、
ただちに false を返します。

要素の数が 0 である配列に対しては true を返します。

@param pattern ブロックの代わりに各要素に対して pattern === item を評価します。

//emlist[例][ruby]{
# すべて正の数か？
p [5, 6, 7].all? {|v| v > 0 } #...

Array#all? {|item| ... } -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が真である場合に true を返します。偽である要素があれば、ただちに false を返します。

Array#all?(pattern) -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が真である場合に true を返します。偽である要素があれば、ただちに false を返します。

絞り込み条件を変える

Array#any? -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が偽である場合に false を返します。真である要素があれば、ただちに true を返します。

すべての要素が偽である場合に false を返します。
真である要素があれば、ただちに true を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果
が偽である場合に false を返します。ブロックが真を返した時点
で、ただちに true を返します。

要素の数が 0 である配列に対しては false を返します。

@param pattern ブロックの代わりに各要素に対して pattern === item を評価します。

//emlist[例][ruby]{
p [1, 2, 3].any? {|v| v > 3 } # => false
p...

Array#any? {|item| ... } -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が偽である場合に false を返します。真である要素があれば、ただちに true を返します。

Array#any?(pattern) -> bool (24025.0)

2.7.0

インスタンスメソッド

すべての要素が偽である場合に false を返します。真である要素があれば、ただちに true を返します。

Array#count -> Integer (24025.0)

2.7.0

インスタンスメソッド

レシーバの要素数を返します。

レシーバの要素数を返します。

引数を指定しない場合は、配列の要素数を返します。

引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの
個数をカウントして返します(一致は == で判定します)。

ブロックを指定した場合は、ブロックを評価して真になった要素の個数を
カウントして返します。

@param item カウント対象となる値。

//emlist[例][ruby]{
ary = [1, 2, 4, 2.0]
ary.count # => 4
ary.count(2) # => 2
ary.count{|x|x%2==0} ...

Array#count {|obj| ... } -> Integer (24025.0)

2.7.0

インスタンスメソッド

レシーバの要素数を返します。

絞り込み条件を変える

Array#count(item) -> Integer (24025.0)

2.7.0

インスタンスメソッド

レシーバの要素数を返します。

Array#drop(n) -> Array (24025.0)

2.7.0

インスタンスメソッド

配列の先頭の n 要素を捨てて、残りの要素を配列として返します。このメソッドは自身を破壊的に変更しません。

配列の先頭の n 要素を捨てて、
残りの要素を配列として返します。
このメソッドは自身を破壊的に変更しません。

@param n 捨てる要素数。

//emlist[例][ruby]{
a = [1, 2, 3, 4, 5, 0]
a.drop(3) # => [4, 5, 0]

# 変数aの値は変化しない
a # => [1, 2, 3, 4, 5, 0]
//}

@see Enumerable#drop, Array#drop_while, Array#shift

Array#drop_while -> Enumerator (24025.0)

2.7.0

インスタンスメソッド

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、残りの要素を配列として返します。このメソッドは自身を破壊的に変更しません。

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、
残りの要素を配列として返します。
このメソッドは自身を破壊的に変更しません。

ブロックを指定しなかった場合は、Enumerator を返します。

//emlist[例][ruby]{
a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 } # => [3, 4, 5, 0]

# 変数aの値は変化しない
a # => [1, 2, 3, 4, 5, 0]
//}

@see Enumerable#drop_while, Array...

Array#drop_while {|element| ... } -> Array (24025.0)

2.7.0

インスタンスメソッド

Array#filter -> Enumerator (24025.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した値が真であった要素を全て含む配列を返します。真になる要素がひとつもなかった場合は空の配列を返します。

各要素に対してブロックを評価した値が真であった要素を全て含む配列を
返します。真になる要素がひとつもなかった場合は空の配列を返します。

ブロックを省略した場合は Enumerator を返します。

//emlist[例][ruby]{
[1,2,3,4,5].select # => #<Enumerator: [1, 2, 3, 4, 5]:select>
[1,2,3,4,5].select { |num| num.even? } # => [2, 4]
//}
@see Enumerable#select
@see Array#select...

絞り込み条件を変える

Array#filter {|item| ... } -> [object] (24025.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した値が真であった要素を全て含む配列を返します。真になる要素がひとつもなかった場合は空の配列を返します。

Array#minmax -> [object, object] (24025.0)

2.7.0

インスタンスメソッド

自身の各要素のうち最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

自身の各要素のうち最小の要素と最大の要素を
要素とするサイズ 2 の配列を返します。

一つ目の形式は、各要素がすべて <=> メソッドを実装していることを仮定し
ています。二つ目の形式では、要素同士の比較をブロックを用いて行います。

//emlist[例][ruby]{
a = %w(albatross dog horse)
a.minmax #=> ["albatross", "horse"]
a.minmax{|a,b| a.length <=> b.length } #=> ["dog", "albatross"]...

Array#minmax {|a, b| ... } -> [object, object] (24025.0)

2.7.0

インスタンスメソッド

自身の各要素のうち最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

Array#none? -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列のすべての要素が偽であれば真を返します。そうでなければ偽を返します。

ブロックを指定しない場合は、配列のすべての
要素が偽であれば真を返します。そうでなければ偽を返します。

ブロックを指定した場合は、配列のすべての要素を
ブロックで評価した結果が、すべて偽であれば真を返します。
そうでなければ偽を返します。

要素の数が 0 である配列に対しては true を返します。

@param pattern ブロックの代わりに各要素に対して pattern === item を評価します。

//emlist[例][ruby]{
%w{ant bear cat}.none? {|word| word.length == 5} # => true
%w{ant ...

Array#none? {|obj| ... } -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列のすべての要素が偽であれば真を返します。そうでなければ偽を返します。

絞り込み条件を変える

Array#none?(pattern) -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列のすべての要素が偽であれば真を返します。そうでなければ偽を返します。

Array#one? -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列の要素のうちちょうど一つだけが真であれば、真を返します。そうでなければ偽を返します。

ブロックを指定しない場合は、配列の要素のうち
ちょうど一つだけが真であれば、真を返します。
そうでなければ偽を返します。

ブロックを指定した場合は、配列の要素を
ブロックで評価した結果、一つの要素だけが真であれば真を返します。
そうでなければ偽を返します。

@param pattern ブロックの代わりに各要素に対して pattern === item を評価します。

//emlist[例][ruby]{
%w{ant bear cat}.one? {|word| word.length == 4} # => true
%w{ant bear cat}.one? {|word| ...

Array#one? {|obj| ... } -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列の要素のうちちょうど一つだけが真であれば、真を返します。そうでなければ偽を返します。

Array#one?(pattern) -> bool (24025.0)

2.7.0

インスタンスメソッド

ブロックを指定しない場合は、配列の要素のうちちょうど一つだけが真であれば、真を返します。そうでなければ偽を返します。

Array#select -> Enumerator (24025.0)

2.7.0

インスタンスメソッド

各要素に対してブロックを評価した値が真であった要素を全て含む配列を返します。真になる要素がひとつもなかった場合は空の配列を返します。

絞り込み条件を変える

<< < 1 2 3 > >>

別のキーワード

種類

クラス

モジュール

オブジェクト

キーワード

検索結果

先頭5件

Enumerable#max {|a, b| ... } -> object | nil (87007.0)

Enumerable#max(n) -> Array (87007.0)

Enumerable#max(n) {|a, b| ... } -> Array (87007.0)

Enumerable#member?(val) -> bool (87007.0)

Enumerable#min -> object | nil (87007.0)

Enumerable#min {|a, b| ... } -> object | nil (87007.0)

Enumerable#min(n) -> Array (87007.0)

Enumerable#min(n) {|a, b| ... } -> Array (87007.0)

Enumerable#partition -> Enumerator (87007.0)

Enumerable#partition {|item| ... } -> [[object], [object]] (87007.0)

Enumerable#reduce(init = self.first) {|result, item| ... } -> object (87007.0)

Enumerable#reduce(init, sym) -> object (87007.0)

Enumerable#reduce(sym) -> object (87007.0)

Enumerable#reverse_each -> Enumerator (87007.0)

Enumerable#reverse_each {|element| ... } -> self (87007.0)

Enumerable#tally -> Hash (87007.0)

Enumerable#to_a(*args) -> [object] (87007.0)

Enumerable#to_h(*args) -> Hash (87007.0)

Enumerable#to_h(*args) { ... } -> Hash (87007.0)

Enumerable#uniq -> Array (87007.0)

Enumerable#uniq { |item| ... } -> Array (87007.0)

Enumerable#zip(*lists) -> [[object]] (87007.0)

Enumerable#zip(*lists) {|v1, v2, ...| ...} -> nil (87007.0)

Enumerator.produce(initial = nil) { |prev| ... } -> Enumerator (24097.0)

Enumerator (24091.0)

Enumerator::ArithmeticSequence#==(other) -> bool (24091.0)

Enumerator::Lazy#grep(pattern) {|item| ... } -> Enumerator::Lazy (24091.0)

Enumerator::Lazy#grep_v(pattern) {|item| ... } -> Enumerator::Lazy (24091.0)

Enumerator::Lazy#take(n) -> Enumerator::Lazy (24091.0)

Enumerator::Lazy#zip(*lists) -> Enumerator::Lazy (24091.0)

Enumerator::Lazy#zip(*lists) {|v1, v2, ...| ... } -> nil (24091.0)

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#chunk(initial_state) {|elt, state| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#collect {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#drop(n) -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#drop_while {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#filter {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#filter_map {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#find_all {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#map {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#reject {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#select {|item| ... } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_after(pattern) -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_before(initial_state) {|elt, state| bool } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_before(pattern) -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#take_while -> Enumerator::Lazy (24073.0)

Enumerator::Lazy#take_while {|item| ... } -> Enumerator::Lazy (24073.0)

ENV.reject -> Enumerator (24055.0)

ENV.reject {|key, value| ... } -> Hash (24055.0)

Enumerator::Chain.new(*enums) -> Enumerator::Chain (24055.0)

Enumerator::Lazy#chunk_while {|elt_before, elt_after| ... } -> Enumerator::Lazy (24055.0)

Enumerator::Lazy#uniq -> Enumerator::Lazy (24055.0)

Enumerator::Lazy#uniq {|item| ... } -> Enumerator::Lazy (24055.0)

Array#collect -> Enumerator (24043.0)

Array#collect {|item| ... } -> [object] (24043.0)

Array#map -> Enumerator (24043.0)

Array#map {|item| ... } -> [object] (24043.0)

Array#reject -> Enumerator (24043.0)

Array#reject {|item| ... } -> [object] (24043.0)

Enumerator::Lazy (24043.0)

Enumerator::Lazy.new(obj, size=nil) {|yielder, *values| ... } -> Enumerator::Lazy (24043.0)

Hash#reject -> Enumerator (24043.0)

Hash#reject {|key, value| ... } -> Hash (24043.0)

Module#prepended(class_or_module) -> () (24043.0)

Object#===(other) -> bool (24043.0)

Range (24043.0)

Array#max -> object | nil (24028.0)

Array#max {|a, b| ... } -> object | nil (24028.0)

Array#max(n) -> Array (24028.0)