Module: Enumerable

Included in:
Array, Hash, Range
Defined in:
mrblib/enum.rb

Overview

Enumerable

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.

Instance Method Summary (collapse)

Instance Method Details

- (Object) __sort_sub__(sorted, work, src_ary, head, tail, &block)

TODO Does this OK? Please test it.



322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'mrblib/enum.rb', line 322

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

- (Boolean) all?(&block)

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

Returns:

  • (Boolean) 


25
26
27
28
29
30
31
32
 
# File 'mrblib/enum.rb', line 25

def all?(&block)
  if block
    self.each{|*val| return false unless block.call(*val)}
  else
    self.each{|*val| return false unless val.__svalue}
  end
  true
end

- (Boolean) any?(&block)

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

Returns:

  • (Boolean) 


42
43
44
45
46
47
48
49
 
# File 'mrblib/enum.rb', line 42

def any?(&block)
  if block
    self.each{|*val| return true if block.call(*val)}
  else
    self.each{|*val| return true if val.__svalue}
  end
  false
end

- (Object) collect(&block) Also known as: map

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



58
59
60
61
62
63
64
 
# File 'mrblib/enum.rb', line 58

def collect(&block)
  return to_enum :collect unless block

  ary = []
  self.each{|*val| ary.push(block.call(*val))}
  ary
end

- (Object) detect(ifnone = nil, &block) Also known as: find

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



74
75
76
77
78
79
80
81
82
83
 
# File 'mrblib/enum.rb', line 74

def detect(ifnone=nil, &block)
  ret = ifnone
  self.each{|*val|
    if block.call(*val)
      ret = val.__svalue
      break
    end
  }
  ret
end

- (Object) each_with_index(&block)

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



92
93
94
95
96
97
98
99
100
101
 
# File 'mrblib/enum.rb', line 92

def each_with_index(&block)
  return to_enum :each_with_index unless block

  i = 0
  self.each{|*val|
    block.call(val.__svalue, i)
    i += 1
  }
  self
end

- (Object) entries Also known as: to_a

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

ISO 15.3.2.2.6



108
109
110
111
112
113
114
115
 
# File 'mrblib/enum.rb', line 108

def entries
  ary = []
  self.each{|*val|
    # __svalue is an internal method
    ary.push val.__svalue
  }
  ary
end

- (Object) find_all(&block) Also known as: select

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



130
131
132
133
134
135
136
137
138
 
# File 'mrblib/enum.rb', line 130

def find_all(&block)
  return to_enum :find_all unless block

  ary = []
  self.each{|*val|
    ary.push(val.__svalue) if block.call(*val)
  }
  ary
end

- (Object) grep(pattern, &block)

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



148
149
150
151
152
153
154
155
156
157
 
# File 'mrblib/enum.rb', line 148

def grep(pattern, &block)
  ary = []
  self.each{|*val|
    sv = val.__svalue
    if pattern === sv
      ary.push((block)? block.call(*val): sv)
    end
  }
  ary
end

- (Object) hash

redefine #hash 15.3.1.3.15



383
384
385
386
387
388
389
390
391
392
 
# File 'mrblib/enum.rb', line 383

def hash
  h = 12347
  i = 0
  self.each do |e|
    n = e.hash << (i % 16)
    h ^= n
    i += 1
  end
  h
end

- (Boolean) include?(obj) Also known as: member?

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

Returns:

  • (Boolean) 


166
167
168
169
170
171
 
# File 'mrblib/enum.rb', line 166

def include?(obj)
  self.each{|*val|
    return true if val.__svalue == obj
  }
  false
end

- (Object) inject(*args, &block) Also known as: reduce

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

Raises:



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'mrblib/enum.rb', line 181

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|
    val = val.__svalue
    if flag
      # push first element as initial
      flag = false
      result = val
    else
      result = block.call(result, val)
    end
  }
  result
end

- (Object) max(&block)

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



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'mrblib/enum.rb', line 222

def max(&block)
  flag = true  # 1st element?
  result = nil
  self.each{|*val|
    val = val.__svalue
    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

- (Object) min(&block)

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



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'mrblib/enum.rb', line 249

def min(&block)
  flag = true  # 1st element?
  result = nil
  self.each{|*val|
    val = val.__svalue
    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

- (Object) partition(&block)

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



285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'mrblib/enum.rb', line 285

def partition(&block)
  ary_T = []
  ary_F = []
  self.each{|*val|
    if block.call(*val)
      ary_T.push(val.__svalue)
    else
      ary_F.push(val.__svalue)
    end
  }
  [ary_T, ary_F]
end

- (Object) reject(&block)

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



305
306
307
308
309
310
311
 
# File 'mrblib/enum.rb', line 305

def reject(&block)
  ary = []
  self.each{|*val|
    ary.push(val.__svalue) unless block.call(*val)
  }
  ary
end

- (Object) sort(&block)

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



367
368
369
370
371
372
373
374
 
# File 'mrblib/enum.rb', line 367

def sort(&block)
  ary = []
  self.each{|*val| ary.push(val.__svalue)}
  if ary.size > 1
    __sort_sub__(ary, ::Array.new(ary.size), 0, 0, ary.size - 1, &block)
  end
  ary
end