Module: Enumerable

Included in:
Array, Enumerator, Enumerator::Generator, Hash, MRuby::Gem::List, MRuby::Gem::Version, Range
Defined in:
ext/enterprise_script_service/mruby/mrblib/enum.rb,
ext/enterprise_script_service/mruby/lib/mruby-core-ext.rb,
ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb,
ext/enterprise_script_service/mruby/mrbgems/mruby-enum-lazy/mrblib/lazy.rb,
ext/enterprise_script_service/mruby/mrbgems/mruby-enumerator/mrblib/enumerator.rb

Overview

Enumerable

Constant Summary collapse

NONE = 
Object.new

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.to_h ⇒ Object 



794
795
796
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 794

def nil.to_h
  {}
end

Instance Method Details

#all?(pat = NONE, &block) ⇒ Boolean

ISO 15.3.2.2.1

call-seq:
   enum.all? [{ |obj| block } ]   -> true or false
   enum.all?(pattern)             -> true or false

Passes each element of the collection to the given block. The method
returns <code>true</code> if the block never returns
<code>false</code> or <code>nil</code>. If the block is not given,
Ruby adds an implicit block of <code>{ |obj| obj }</code> which will
cause #all? to return +true+ when none of the collection members are
+false+ or +nil+.

If a pattern is supplied instead, the method returns whether
<code>pattern === element</code> for every collection member.

   %w[ant bear cat].all? { |word| word.length >= 3 } #=> true
   %w[ant bear cat].all? { |word| word.length >= 4 } #=> false
   %w[ant bear cat].all?(/t/)                        #=> false
   [1, 2i, 3.14].all?(Numeric)                       #=> true
   [nil, true, 99].all?                              #=> false

Returns:

  • (Boolean) 


24
25
26
27
28
29
30
31
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 24

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

#any?(pat = NONE, &block) ⇒ Boolean

ISO 15.3.2.2.2

call-seq:
   enum.any? [{ |obj| block }]   -> true or false
   enum.any?(pattern)            -> true or false

Passes each element of the collection to the given block. The method
returns <code>true</code> if the block ever returns a value other
than <code>false</code> or <code>nil</code>. If the block is not
given, Ruby adds an implicit block of <code>{ |obj| obj }</code> that
will cause #any? to return +true+ if at least one of the collection
members is not +false+ or +nil+.

If a pattern is supplied instead, the method returns whether
<code>pattern === element</code> for any collection member.

   %w[ant bear cat].any? { |word| word.length >= 3 } #=> true
   %w[ant bear cat].any? { |word| word.length >= 4 } #=> true
   %w[ant bear cat].any?(/d/)                        #=> false
   [nil, true, 99].any?(Integer)                     #=> true
   [nil, true, 99].any?                              #=> true
   [].any?                                           #=> false

Returns:

  • (Boolean) 


41
42
43
44
45
46
47
48
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 41

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

#collect(&block) ⇒ Object 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



57
58
59
60
61
62
63
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 57

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

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

#count(v = NONE, &block) ⇒ Object

call-seq:

enum.count                 -> int
enum.count(item)           -> int
enum.count { |obj| block } -> int

Returns the number of items in enum through enumeration. If an argument is given, the number of items in enum that are equal to item are counted. If a block is given, it counts the number of elements yielding a true value.



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 255

def count(v=NONE, &block)
  count = 0
  if block
    self.each do |*val|
      count += 1 if block.call(*val)
    end
  else
    if v == NONE
      self.each { count += 1 }
    else
      self.each do |*val|
        count += 1 if val.__svalue == v
      end
    end
  end
  count
end

#cycle(nv = nil, &block) ⇒ Object

call-seq:

   enum.cycle(n=nil) { |obj| block }  ->  nil
   enum.cycle(n=nil)                  ->  an_enumerator

Calls <i>block</i> for each element of <i>enum</i> repeatedly _n_
times or forever if none or +nil+ is given.  If a non-positive
number is given or the collection is empty, does nothing.  Returns
+nil+ if the loop has finished without getting interrupted.

Enumerable#cycle saves elements in an internal array so changes
to <i>enum</i> after the first pass have no effect.

If no block is given, an enumerator is returned instead.

   a = ["a", "b", "c"]
   a.cycle { |x| puts x }  # print, a, b, c, a, b, c,.. forever.
   a.cycle(2) { |x| puts x }  # print, a, b, c, a, b, c.



672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 672

def cycle(nv = nil, &block)
  return to_enum(:cycle, nv) unless block

  n = nil

  if nv.nil?
    n = -1
  else
    unless nv.respond_to?(:to_int)
      raise TypeError, "no implicit conversion of #{nv.class} into Integer"
    end
    n = nv.to_int
    unless n.kind_of?(Integer)
      raise TypeError, "no implicit conversion of #{nv.class} into Integer"
    end
    return nil if n <= 0
  end

  ary = []
  each do |*i|
    ary.push(i)
    yield(*i)
  end
  return nil if ary.empty?

  while n < 0 || 0 < (n -= 1)
    ary.each do |i|
      yield(*i)
    end
  end

  nil
end

#detect(ifnone = nil, &block) ⇒ Object 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



73
74
75
76
77
78
79
80
81
82
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 73

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

#drop(n) ⇒ Object

call-seq:

enum.drop(n)               -> array

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]

Raises:



15
16
17
18
19
20
21
22
23
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 15

def drop(n)
  raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
  raise ArgumentError, "attempt to drop negative size" if n < 0

  n = n.to_int
  ary = []
  self.each {|*val| n == 0 ? ary << val.__svalue : n -= 1 }
  ary
end

#drop_while(&block) ⇒ Object

call-seq:

enum.drop_while {|arr| block }   -> array
enum.drop_while                  -> an_enumerator

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.

If no block is given, an enumerator is returned instead.

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



39
40
41
42
43
44
45
46
47
48
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 39

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

  ary, state = [], false
  self.each do |*val|
    state = true if !state and !block.call(*val)
    ary << val.__svalue if state
  end
  ary
end

#each_cons(n, &block) ⇒ nil

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

Examples:

(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]

Returns:

  • (nil)

Raises:



115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 115

def each_cons(n, &block)
  raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
  raise ArgumentError, "invalid size" if n <= 0

  return to_enum(:each_cons,n) unless block
  ary = []
  n = n.to_int
  self.each do |*val|
    ary.shift if ary.size == n
    ary << val.__svalue
    block.call(ary.dup) if ary.size == n
  end
  nil
end

#each_slice(n, &block) ⇒ nil

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

Examples:

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

Returns:

  • (nil)

Raises:



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 143

def each_slice(n, &block)
  raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
  raise ArgumentError, "invalid slice size" if n <= 0

  return to_enum(:each_slice,n) unless block
  ary = []
  n = n.to_int
  self.each do |*val|
    ary << val.__svalue
    if ary.size == n
      block.call(ary)
      ary = []
    end
  end
  block.call(ary) unless ary.empty?
  nil
end

#each_with_index(&block) ⇒ Object

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



91
92
93
94
95
96
97
98
99
100
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 91

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

#each_with_object(obj = nil, &block) ⇒ Object

call-seq:

  enum.each_with_object(obj) { |(*args), memo_obj| ... }  ->  obj
  enum.each_with_object(obj)                              ->  an_enumerator

Iterates the given block for each element with an arbitrary
object given, and returns the initially given object.

If no block is given, returns an enumerator.

   (1..10).each_with_object([]) { |i, a| a << i*2 }
   #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Raises:



47
48
49
50
51
 
# File 'ext/enterprise_script_service/mruby/lib/mruby-core-ext.rb', line 47

def each_with_object(memo)
  return to_enum :each_with_object, memo unless block_given?
  each { |obj| yield obj, memo }
  memo
end

#entries ⇒ Object Also known as: to_a

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

ISO 15.3.2.2.6



107
108
109
110
111
112
113
114
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 107

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

#find_all(&block) ⇒ Object 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



129
130
131
132
133
134
135
136
137
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 129

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

#find_index(val = NONE, &block) ⇒ Object

call-seq:

   enum.find_index(value)          -> int or nil
   enum.find_index { |obj| block } -> int or nil
   enum.find_index                 -> an_enumerator

Compares each entry in <i>enum</i> with <em>value</em> or passes
to <em>block</em>.  Returns the index for the first for which the
evaluated value is non-false.  If no object matches, returns
<code>nil</code>

If neither block nor argument is given, an enumerator is returned instead.

   (1..10).find_index  { |i| i % 5 == 0 and i % 7 == 0 }  #=> nil
   (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 }  #=> 34
   (1..100).find_index(50)                                #=> 49



724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 724

def find_index(val=NONE, &block)
  return to_enum(:find_index, val) if !block && val == NONE

  idx = 0
  if block
    self.each do |*e|
      return idx if block.call(*e)
      idx += 1
    end
  else
    self.each do |*e|
      return idx if e.__svalue == val
      idx += 1
    end
  end
  nil
end

#first(*args) ⇒ Object

call-seq:

enum.first       ->  obj or nil
enum.first(n)    ->  an_array

Returns the first element, or the first n elements, of the enumerable. If the enumerable is empty, the first form returns nil, and the second form returns an empty array.



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 220

def first(*args)
  case args.length
  when 0
    self.each do |*val|
      return val.__svalue
    end
    return nil
  when 1
    n = args[0]
    raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
    i = n.to_int
    raise ArgumentError, "attempt to take negative size" if i < 0
    ary = []
    return ary if i == 0
    self.each do |*val|
      ary << val.__svalue
      i -= 1
      break if i == 0
    end
    ary
  else
    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)"
  end
end

#flat_map(&block) ⇒ Object Also known as: collect_concat

call-seq:

enum.flat_map       { |obj| block } -> array
enum.collect_concat { |obj| block } -> array
enum.flat_map                       -> an_enumerator
enum.collect_concat                 -> an_enumerator

Returns a new array with the concatenated results of running block once for every element in enum.

If no block is given, an enumerator is returned instead.

[1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4]
[[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100]



287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 287

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

  ary = []
  self.each do |*e|
    e2 = block.call(*e)
    if e2.respond_to? :each
      e2.each {|e3| ary.push(e3) }
    else
      ary.push(e2)
    end
  end
  ary
end

#grep(pattern, &block) ⇒ Object

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



147
148
149
150
151
152
153
154
155
156
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 147

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

#group_by(&block) ⇒ Object

call-seq:

enum.group_by {| obj | block }  -> a_hash
enum.group_by                   -> an_enumerator

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]}



172
173
174
175
176
177
178
179
180
181
182
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 172

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

  h = {}
  self.each do |*val|
    key = block.call(*val)
    sv = val.__svalue
    h.key?(key) ? (h[key] << sv) : (h[key] = [sv])
  end
  h
end

#hash ⇒ Object

redefine #hash 15.3.1.3.15



338
339
340
341
342
343
344
345
346
347
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 338

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

#include?(obj) ⇒ Boolean 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) 


165
166
167
168
169
170
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 165

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

#inject(*args, &block) ⇒ Object 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:



180
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
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 180

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

#lazy ⇒ Object

Enumerable#lazy implementation

Enumerable#lazy returns an instance of Enumerator::Lazy. You can use it just like as normal Enumerable object, except these methods act as ‘lazy’:

- map       collect
- select    find_all
- reject
- grep
- drop
- drop_while
- take_while
- flat_map  collect_concat
- zip



18
19
20
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 18

def lazy
  Enumerator::Lazy.new(self)
end

#max(&block) ⇒ Object

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



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

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

#max_by(&block) ⇒ Object

call-seq:

enum.max_by {|obj| block }      -> obj
enum.max_by                     -> an_enumerator

Returns the object in enum that gives the maximum value from the given block.

If no block is given, an enumerator is returned instead.

%w[albatross dog horse].max_by {|x| x.length }   #=> "albatross"



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 315

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

  first = true
  max = nil
  max_cmp = nil

  self.each do |*val|
    if first
      max = val.__svalue
      max_cmp = block.call(*val)
      first = false
    else
      if (cmp = block.call(*val)) > max_cmp
        max = val.__svalue
        max_cmp = cmp
      end
    end
  end
  max
end

#min(&block) ⇒ Object

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



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

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

#min_by(&block) ⇒ Object

call-seq:

enum.min_by {|obj| block }      -> obj
enum.min_by                     -> an_enumerator

Returns the object in enum that gives the minimum value from the given block.

If no block is given, an enumerator is returned instead.

%w[albatross dog horse].min_by {|x| x.length }   #=> "dog"



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 349

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

  first = true
  min = nil
  min_cmp = nil

  self.each do |*val|
    if first
      min = val.__svalue
      min_cmp = block.call(*val)
      first = false
    else
      if (cmp = block.call(*val)) < min_cmp
        min = val.__svalue
        min_cmp = cmp
      end
    end
  end
  min
end

#minmax(&block) ⇒ Object

call-seq:

   enum.minmax                  -> [min, max]
   enum.minmax { |a, b| block } -> [min, max]

Returns two elements array which contains the minimum and the
maximum value in the enumerable.  The first form assumes all
objects implement <code>Comparable</code>; the second uses the
block to return <em>a <=> b</em>.

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



385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 385

def minmax(&block)
  max = nil
  min = nil
  first = true

  self.each do |*val|
    if first
      val = val.__svalue
      max = val
      min = val
      first = false
    else
      val = val.__svalue
      if block
        max = val if block.call(val, max) > 0
        min = val if block.call(val, min) < 0
      else
        max = val if (val <=> max) > 0
        min = val if (val <=> min) < 0
      end
    end
  end
  [min, max]
end

#minmax_by(&block) ⇒ Object

call-seq:

   enum.minmax_by { |obj| block } -> [min, max]
   enum.minmax_by                 -> an_enumerator

Returns a two element array containing the objects in
<i>enum</i> that correspond to the minimum and maximum values respectively
from the given block.

If no block is given, an enumerator is returned instead.

   %w(albatross dog horse).minmax_by { |x| x.length }   #=> ["dog", "albatross"]



423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 423

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

  max = nil
  max_cmp = nil
  min = nil
  min_cmp = nil
  first = true

  self.each do |*val|
    if first
      max = min = val.__svalue
      max_cmp = min_cmp = block.call(*val)
      first = false
   else
      if (cmp = block.call(*val)) > max_cmp
        max = val.__svalue
        max_cmp = cmp
      end
      if (cmp = block.call(*val)) < min_cmp
        min = val.__svalue
        min_cmp = cmp
      end
    end
  end
  [min, max]
end

#none?(pat = NONE, &block) ⇒ Boolean

call-seq:

   enum.none? [{ |obj| block }]   -> true or false
   enum.none?(pattern)            -> true or false

Passes each element of the collection to the given block. The method
returns <code>true</code> if the block never returns <code>true</code>
for all elements. If the block is not given, <code>none?</code> will return
<code>true</code> only if none of the collection members is true.

If a pattern is supplied instead, the method returns whether
<code>pattern === element</code> for none of the collection members.

   %w(ant bear cat).none? { |word| word.length == 5 } #=> true
   %w(ant bear cat).none? { |word| word.length >= 4 } #=> false
   %w{ant bear cat}.none?(/d/)                        #=> true
   [1, 3.14, 42].none?(Float)                         #=> false
   [].none?                                           #=> true
   [nil, false].none?                                 #=> true
   [nil, true].none?                                  #=> false

Returns:

  • (Boolean) 


472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 472

def none?(pat=NONE, &block)
  if pat != NONE
    self.each do |*val|
      return false if pat === val.__svalue
    end
  elsif block
    self.each do |*val|
      return false if block.call(*val)
    end
  else
    self.each do |*val|
      return false if val.__svalue
    end
  end
  true
end

#one?(pat = NONE, &block) ⇒ Boolean

call-seq:

enum.one? [{ |obj| block }]   -> true or false
enum.one?(pattern)            -> true or false

Passes each element of the collection to the given block. The method returns true if the block returns true exactly once. If the block is not given, one? will return true only if exactly one of the collection members is true.

If a pattern is supplied instead, the method returns whether pattern === element for exactly one collection member.

%w(ant bear cat).one? { |word| word.length == 4 }  #=> true
%w(ant bear cat).one? { |word| word.length > 4 }   #=> false
%w(ant bear cat).one? { |word| word.length < 4 }   #=> false
%w{ant bear cat}.one?(/t/)                         #=> false
[nil, true, 99].one?                               #=> false
[nil, true, false].one?                            #=> true
[ nil, true, 99 ].one?(Integer)                    #=> true
[].one?                                            #=> false

Returns:

  • (Boolean) 


512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 512

def one?(pat=NONE, &block)
  count = 0
  if pat!=NONE
    self.each do |*val|
      count += 1 if pat === val.__svalue
      return false if count > 1
    end
  elsif block
    self.each do |*val|
      count += 1 if block.call(*val)
      return false if count > 1
    end
  else
    self.each do |*val|
      count += 1 if val.__svalue
      return false if count > 1
    end
  end

  count == 1 ? true : false
end

#partition(&block) ⇒ Object

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



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

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

#reject(&block) ⇒ Object

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



304
305
306
307
308
309
310
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 304

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

#reverse_each(&block) ⇒ Object

call-seq:

   enum.reverse_each { |item| block } ->  enum
   enum.reverse_each                  ->  an_enumerator

Builds a temporary array and traverses that array in reverse order.

If no block is given, an enumerator is returned instead.

    (1..3).reverse_each { |v| p v }

  produces:

    3
    2
    1



640
641
642
643
644
645
646
647
648
649
650
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 640

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

  ary = self.to_a
  i = ary.size - 1
  while i>=0
    block.call(ary[i])
    i -= 1
  end
  self
end

#sort(&block) ⇒ Object

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



327
328
329
 
# File 'ext/enterprise_script_service/mruby/mrblib/enum.rb', line 327

def sort(&block)
  self.map{|*val| val.__svalue}.sort
end

#sort_by(&block) ⇒ Object

call-seq:

enum.sort_by { |obj| block }   -> array
enum.sort_by                   -> an_enumerator

Sorts enum using a set of keys generated by mapping the values in enum through the given block.

If no block is given, an enumerator is returned instead.



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 194

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

  ary = []
  orig = []
  self.each_with_index{|e, i|
    orig.push(e)
    ary.push([block.call(e), i])
  }
  if ary.size > 1
    __sort_sub__(ary, 0, ary.size - 1) do |a,b|
      a <=> b
    end
  end
  ary.collect{|e,i| orig[i]}
end

#take(n) ⇒ Object

call-seq:

enum.take(n)               -> array

Returns first n elements from enum.

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

Raises:



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 59

def take(n)
  raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
  i = n.to_int
  raise ArgumentError, "attempt to take negative size" if i < 0
  ary = []
  return ary if i == 0
  self.each do |*val|
    ary << val.__svalue
    i -= 1
    break if i == 0
  end
  ary
end

#take_while(&block) ⇒ Object

call-seq:

enum.take_while {|arr| block }   -> array
enum.take_while                  -> an_enumerator

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

If no block is given, an enumerator is returned instead.

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



86
87
88
89
90
91
92
93
94
95
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 86

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

  ary = []
  self.each do |*val|
    return ary unless block.call(*val)
    ary << val.__svalue
  end
  ary
end

#to_h ⇒ Object

call-seq:

   enum.to_h  -> hash

Returns the result of interpreting <i>enum</i> as a list of
<tt>[key, value]</tt> pairs.

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



783
784
785
786
787
788
789
790
791
792
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 783

def to_h
  h = {}
  self.each do |*v|
    v = v.__svalue
    raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array
    raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2
    h[v[0]] = v[1]
  end
  h
end

#uniq(&block) ⇒ Object 



798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 798

def uniq(&block)
  hash = {}
  if block
    self.each do|*v|
      v = v.__svalue
      hash[block.call(v)] ||= v
    end
  else
    self.each do|*v|
      v = v.__svalue
      hash[v] ||= v
    end
  end
  hash.values
end

#zip(*arg) ⇒ Object

use Enumerator to use infinite sequence



754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb', line 754

def zip(*arg)
  ary = []
  arg = arg.map{|a|a.to_a}
  i = 0
  self.each do |*val|
    a = []
    a.push(val.__svalue)
    idx = 0
    while idx < arg.size
      a.push(arg[idx][i])
      idx += 1
    end
    ary.push(a)
    i += 1
  end
  ary
end