Class: Enumerator::Lazy

Inherits:
Enumerator
  • Object
show all
Defined in:
mrbgems/mruby-enum-lazy/mrblib/lazy.rb

Overview

Acknowledgements

Based on https://github.com/yhara/enumerable-lazy
Inspired by https://github.com/antimon2/enumerable_lz
http://jp.rubyist.net/magazine/?0034-Enumerable_lz (ja)

Instance Method Summary collapse

Constructor Details

#initialize(obj, &block) ⇒ Lazy

Returns a new instance of Lazy.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 31

def initialize(obj, &block)
  super(){|yielder|
    begin
      obj.each{|x|
        if block
          block.call(yielder, x)
        else
          yielder << x
        end
      }
    rescue StopIteration
    end
  }
end

Instance Method Details

#drop(n) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 101

def drop(n)
  dropped = 0
  Lazy.new(self){|yielder, val|
    if dropped < n
      dropped += 1
    else
      yielder << val
    end
  }
end

#drop_while(&block) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 112

def drop_while(&block)
  dropping = true
  Lazy.new(self){|yielder, val|
    if dropping
      if not block.call(val)
        yielder << val
        dropping = false
      end
    else
      yielder << val
    end
  }
end

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



150
151
152
153
154
155
156
157
158
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 150

def flat_map(&block)
  Lazy.new(self){|yielder, val|
    ary = block.call(val)
    # TODO: check ary is an Array
    ary.each{|x|
      yielder << x
    }
  }
end

#grep(pattern) ⇒ Object 



85
86
87
88
89
90
91
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 85

def grep(pattern)
  Lazy.new(self){|yielder, val|
    if pattern === val
      yielder << val
    end
  }
end

#grep_v(pattern) ⇒ Object 



93
94
95
96
97
98
99
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 93

def grep_v(pattern)
  Lazy.new(self){|yielder, val|
    unless pattern === val
      yielder << val
    end
  }
end

#map(&block) ⇒ Object Also known as: collect 



61
62
63
64
65
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 61

def map(&block)
  Lazy.new(self){|yielder, val|
    yielder << block.call(val)
  }
end

#reject(&block) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 77

def reject(&block)
  Lazy.new(self){|yielder, val|
    unless block.call(val)
      yielder << val
    end
  }
end

#select(&block) ⇒ Object Also known as: find_all 



68
69
70
71
72
73
74
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 68

def select(&block)
  Lazy.new(self){|yielder, val|
    if block.call(val)
      yielder << val
    end
  }
end

#take(n) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 126

def take(n)
  if n == 0
    return Lazy.new(self){raise StopIteration}
  end
  taken = 0
  Lazy.new(self){|yielder, val|
    yielder << val
    taken += 1
    if taken >= n
      raise StopIteration
    end
  }
end

#take_while(&block) ⇒ Object 



140
141
142
143
144
145
146
147
148
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 140

def take_while(&block)
  Lazy.new(self){|yielder, val|
    if block.call(val)
      yielder << val
    else
      raise StopIteration
    end
  }
end

#to_enum(meth = :each, *args, &block) ⇒ Object Also known as: enum_for 



46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 46

def to_enum(meth=:each, *args, &block)
  unless self.respond_to?(meth)
    raise ArgumentError, "undefined method #{meth}"
  end
  lz = Lazy.new(self, &block)
  obj = self
  lz.instance_eval {
    @obj = obj
    @meth = meth
    @args = args
  }
  lz
end

#uniq(&block) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 173

def uniq(&block)
  hash = {}
  Lazy.new(self){|yielder, val|
    if block
      v = block.call(val)
    else
      v = val
    end
    unless hash.include?(v)
      yielder << val
      hash[v] = val
    end
  }
end

#zip(*args, &block) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
 
# File 'mrbgems/mruby-enum-lazy/mrblib/lazy.rb', line 161

def zip(*args, &block)
  enums = [self] + args
  Lazy.new(self){|yielder, val|
    ary = enums.map{|e| e.next}
    if block
      yielder << block.call(ary)
    else
      yielder << ary
    end
  }
end