Enumerable

Array is enumerable and comparable

ISO 15.3.2

The <code>Enumerable</code> mixin provides collection classes with
several traversal and searching methods, and with the ability to
sort. The class must provide a method <code>each</code>, which
yields successive members of the collection. If
<code>Enumerable#max</code>, <code>#min</code>, or
<code>#sort</code> is used, the objects in the collection must also
implement a meaningful <code><=></code> operator, as these methods
rely on an ordering between members of the collection.

Hash is enumerable

ISO 15.2.13.3

Range is enumerable

ISO 15.2.14.3

Public Instance Methods

__sort_sub__(sorted, work, src_ary, head, tail, &block) click to toggle source

TODO Does this OK? Please test it.

 
               # File mrblib/enum.rb, line 339
def __sort_sub__(sorted, work, src_ary, head, tail, &block)
  if head == tail
    sorted[head] = work[head] if src_ary == 1
    return
  end

  # on current step, which is a src ary?
  if src_ary == 0
    src, dst = sorted, work
  else
    src, dst = work, sorted
  end

  key = src[head]    # key value for dividing values
  i, j = head, tail  # position to store on the dst ary

  (head + 1).upto(tail){|idx|
    if ((block)? block.call(src[idx], key): (src[idx] <=> key)) > 0
      # larger than key
      dst[j] = src[idx]
      j -= 1
    else
      dst[i] = src[idx]
      i += 1
    end
  }

  sorted[i] = key

  # sort each sub-array
  src_ary = (src_ary + 1) % 2  # exchange a src ary
  __sort_sub__(sorted, work, src_ary, head, i - 1, &block) if i > head
  __sort_sub__(sorted, work, src_ary, i + 1, tail, &block) if i < tail
end

all?(&block) click to toggle source

Call the given block for each element which is yield by each. Return false if one block value is false. Otherwise return true. If no block is given and self is false return false.

ISO 15.3.2.2.1

 
               # File mrblib/enum.rb, line 25
def all?(&block)
  st = true
  if block
    self.each{|val|
      unless block.call(val)
        st = false
        break
      end
    }
  else
    self.each{|val|
      unless val
        st = false
        break
      end
    }
  end
  st
end

any?(&block) click to toggle source

Call the given block for each element which is yield by each. Return true if one block value is true. Otherwise return false. If no block is given and self is true object return true.

ISO 15.3.2.2.2

 
               # File mrblib/enum.rb, line 53
def any?(&block)
  st = false
  if block
    self.each{|val|
      if block.call(val)
        st = true
        break
      end
    }
  else
    self.each{|val|
      if val
        st = true
        break
      end
    }
  end
  st
end

collect(&block) click to toggle source

Call the given block for each element which is yield by each. Append all values of each block together and return this value.

ISO 15.3.2.2.3

 
               # File mrblib/enum.rb, line 80
def collect(&block)
  ary = []
  self.each{|val|
    ary.push(block.call(val))
  }
  ary
end

Also aliased as: map

detect(ifnone=nil, &block) click to toggle source

Call the given block for each element which is yield by each. Return ifnone if no block value was true. Otherwise return the first block value which had was true.

ISO 15.3.2.2.4

 
               # File mrblib/enum.rb, line 96
def detect(ifnone=nil, &block)
  ret = ifnone
  self.each{|val|
    if block.call(val)
      ret = val
      break
    end
  }
  ret
end

Also aliased as: find

drop(n) → array click to toggle source

Drops first n elements from enum, and returns rest elements in an array.

a = [1, 2, 3, 4, 5, 0]
a.drop(3)             #=> [4, 5, 0]

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 15
def drop(n)
  raise TypeError, "expected Integer for 1st argument" unless n.kind_of? Integer
  raise ArgumentError, "attempt to drop negative size" if n < 0

  ary = []
  self.each {|e| n == 0 ? ary << e : n -= 1 }
  ary
end

drop_while {|arr| block } → array click to toggle source

Drops elements up to, but not including, the first element for which the block returns nil or false and returns an array containing the remaining elements.

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

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 35
def drop_while(&block)
  ary, state = [], false
  self.each do |e|
    state = true if !state and !block.call(e)
    ary << e if state
  end
  ary
end

each_cons(n) {...} → nil click to toggle source

Iterates the given block for each array of consecutive <n> elements.

e.g.:

(1..10).each_cons(3) {|a| p a}
# outputs below
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]
[8, 9, 10]

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 104
def each_cons(n, &block)
  raise TypeError, "expected Integer for 1st argument" unless n.kind_of? Integer
  raise ArgumentError, "invalid size" if n <= 0

  ary = []
  self.each do |e|
    ary.shift if ary.size == n
    ary << e
    block.call(ary.dup) if ary.size == n
  end
end

each_slice(n) {...} → nil click to toggle source

Iterates the given block for each slice of <n> elements.

e.g.:

(1..10).each_slice(3) {|a| p a}
# outputs below
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 130
def each_slice(n, &block)
  raise TypeError, "expected Integer for 1st argument" unless n.kind_of? Integer
  raise ArgumentError, "invalid slice size" if n <= 0

  ary = []
  self.each do |e|
    ary << e
    if ary.size == n
      block.call(ary)
      ary = []
    end
  end
  block.call(ary) unless ary.empty?
end

each_with_index(&block) click to toggle source

Call the given block for each element which is yield by each. Pass an index to the block which starts at 0 and increase by 1 for each element.

ISO 15.3.2.2.5

 
               # File mrblib/enum.rb, line 114
def each_with_index(&block)
  i = 0
  self.each{|val|
    block.call(val, i)
    i += 1
  }
  self
end

entries() click to toggle source

Return an array of all elements which are yield by each.

ISO 15.3.2.2.6

 
               # File mrblib/enum.rb, line 128
def entries
  ary = []
  self.each{|val|
    ary.push val
  }
  ary
end

Also aliased as: to_a

find(ifnone=nil, &block) click to toggle source

Alias for find

ISO 15.3.2.2.7

Alias for: detect

find_all(&block) click to toggle source

Call the given block for each element which is yield by each. Return an array which contains all elements whose block value was true.

ISO 15.3.2.2.8

 
               # File mrblib/enum.rb, line 149
def find_all(&block)
  ary = []
  self.each{|val|
    ary.push(val) if block.call(val)
  }
  ary
end

Also aliased as: select

grep(pattern, &block) click to toggle source

Call the given block for each element which is yield by each and which return value was true when invoking === with pattern. Return an array with all elements or the respective block values.

ISO 15.3.2.2.9

 
               # File mrblib/enum.rb, line 165
def grep(pattern, &block)
  ary = []
  self.each{|val|
    if pattern === val
      ary.push((block)? block.call(val): val)
    end
  }
  ary
end

group_by {| obj | block } → a_hash click to toggle source

Returns a hash, which keys are evaluated result from the block, and values are arrays of elements in enum corresponding to the key.

(1..6).group_by {|i| i%3}   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 155
def group_by(&block)
  h = {}
  self.each do |e|
    key = block.call(e)
    h.key?(key) ? (h[key] << e) : (h[key] = [e])
  end
  h
end

include?(obj) click to toggle source

Return true if at least one element which is yield by each returns a true value by invoking == with obj. Otherwise return false.

ISO 15.3.2.2.10

 
               # File mrblib/enum.rb, line 182
def include?(obj)
  st = false
  self.each{|val|
    if val == obj
      st = true
      break
    end
  }
  st
end

Also aliased as: member?

inject(*args, &block) click to toggle source

Call the given block for each element which is yield by each. Return value is the sum of all block values. Pass to each block the current sum and the current element.

ISO 15.3.2.2.11

 
               # File mrblib/enum.rb, line 201
def inject(*args, &block)
  raise ArgumentError, "too many arguments" if args.size > 2
  if Symbol === args[-1]
    sym = args[-1]
    block = ->(x,y){x.send(sym,y)}
    args.pop
  end
  if args.empty?
    flag = true  # no initial argument
    result = nil
  else
    flag = false
    result = args[0]
  end
  self.each{|val|
    if flag
      # push first element as initial
      flag = false
      result = val
    else
      result = block.call(result, val)
    end
  }
  result
end

Also aliased as: reduce

map(&block) click to toggle source

Alias for collect

ISO 15.3.2.2.12

Alias for: collect

max(&block) click to toggle source

Return the maximum value of all elements yield by each. If no block is given <=> will be invoked to define this value. If a block is given it will be used instead.

ISO 15.3.2.2.13

 
               # File mrblib/enum.rb, line 241
def max(&block)
  flag = true  # 1st element?
  result = nil
  self.each{|val|
    if flag
      # 1st element
      result = val
      flag = false
    else
      if block
        result = val if block.call(val, result) > 0
      else
        result = val if (val <=> result) > 0
      end
    end
  }
  result
end

member?(obj) click to toggle source

Alias for include?

ISO 15.3.2.2.15

Alias for: include?

min(&block) click to toggle source

Return the minimum value of all elements yield by each. If no block is given <=> will be invoked to define this value. If a block is given it will be used instead.

ISO 15.3.2.2.14

 
               # File mrblib/enum.rb, line 267
def min(&block)
  flag = true  # 1st element?
  result = nil
  self.each{|val|
    if flag
      # 1st element
      result = val
      flag = false
    else
      if block
        result = val if block.call(val, result) < 0
      else
        result = val if (val <=> result) < 0
      end
    end
  }
  result
end

partition(&block) click to toggle source

Call the given block for each element which is yield by each. Return an array which contains two arrays. The first array contains all elements whose block value was true. The second array contains all elements whose block value was false.

ISO 15.3.2.2.16

 
               # File mrblib/enum.rb, line 302
def partition(&block)
  ary_T = []
  ary_F = []
  self.each{|val|
    if block.call(val)
      ary_T.push(val)
    else
      ary_F.push(val)
    end
  }
  [ary_T, ary_F]
end

reduce(*args, &block) click to toggle source

Alias for: inject

reject(&block) click to toggle source

Call the given block for each element which is yield by each. Return an array which contains only the elements whose block value was false.

ISO 15.3.2.2.17

 
               # File mrblib/enum.rb, line 322
def reject(&block)
  ary = []
  self.each{|val|
    ary.push(val) unless block.call(val)
  }
  ary
end

select(&block) click to toggle source

Alias for find_all.

ISO 15.3.2.2.18

Alias for: find_all

sort(&block) click to toggle source

Return a sorted array of all elements which are yield by each. If no block is given <=> will be invoked on each element to define the order. Otherwise the given block will be used for sorting.

ISO 15.3.2.2.19

 
               # File mrblib/enum.rb, line 384
def sort(&block)
  ary = []
  self.each{|val| ary.push(val)}
  unless ary.empty?
    __sort_sub__(ary, ::Array.new(ary.size), 0, 0, ary.size - 1, &block)
  end
  ary
end

take(n) → array click to toggle source

Returns first n elements from enum.

a = [1, 2, 3, 4, 5, 0]
a.take(3)             #=> [1, 2, 3]

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 53
def take(n)
  raise TypeError, "expected Integer for 1st argument" unless n.kind_of? Integer
  raise ArgumentError, "attempt to take negative size" if n < 0

  ary = []
  self.each do |e|
    break if ary.size >= n
    ary << e
  end
  ary
end

take_while {|arr| block } → array click to toggle source

Passes elements to the block until the block returns nil or false, then stops iterating and returns an array of all prior elements.

a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 }   #=> [1, 2]

 
               # File mrbgems/mruby-enum-ext/mrblib/enum.rb, line 76
def take_while(&block)
  ary = []
  self.each do |e|
    return ary unless block.call(e)
    ary << e
  end
  ary
end

to_a() click to toggle source

Alias for entries.

ISO 15.3.2.2.20

Alias for: entries

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please see Improve the docs, or visit Documenting-ruby.org.

Home Classes Methods

In Files

Methods

Files

Class/Module Index

Enumerable

Public Instance Methods