mruby 惰性求值实战指南:用 mruby-enum-lazy 的 Enumerator::Lazy 处理大规模与无限序列
mruby 惰性求值实战指南:用 mruby-enum-lazy 的 Enumerator::Lazy 处理大规模与无限序列
mruby-enum-lazy 是 mruby 官方标准库(stdlib gembox)中的一个 mrbgem,它为 Enumerable 引入惰性求值(lazy evaluation)能力:通过 Enumerable#lazy 返回一个 Enumerator::Lazy 对象,将 map、select、take 等变换操作延迟到真正需要结果时才执行。阅读本文后,你将掌握 Enumerator::Lazy 的全部惰性方法(含 grep_v、tap_each、flat_map 等)的语义、链式调用的执行时序、无限序列的安全处理技巧,以及如何在自己的 mruby 构建中启用该 gem 并利用其源码与测试验证行为。
概览:mruby 中的惰性求值
在普通的 mruby Enumerable 处理流程中,每调用一次 map、select 都会立刻遍历整个集合并生成一个完整的新数组。当集合很大,或者我们只需要前几个结果时,这种"急迫求值"(eager evaluation)会浪费大量 CPU 时间和内存。
mruby-enum-lazy 解决的正是这一问题:它为 Enumerable 引入 #lazy 方法,返回一个 Enumerator::Lazy 实例。这个对象的行为与普通 Enumerator 相似,但关键区别在于——对集合做变换的方法会被挂起(deferred),直到结果真正被需要时(例如调用 force、to_a,或通过 each 迭代)才逐元素执行。
从实现角度看,该 gem 的核心代码全部位于 mrblib/lazy.rb:
Enumerable#lazy只是简单地构造Enumerator::Lazy.new(self)(lazy.rb#L32-L34);Enumerator::Lazy < Enumerator,它复用 mruby 核心 gem mruby-enumerator 提供的Enumerator基础设施,在其上重定义了大量本应"急迫"的方法。
在 doc/guides/language.md 的"标准库(gembox)"对照表中,
Enumerator::Lazy被明确归类为:Gemboxstdlib、Gemmruby-enum-lazy。
功能清单:哪些方法被惰性化
调用 .lazy 后,以下方法被重新实现为惰性链式操作,每次调用都会返回一个新的 Enumerator::Lazy 对象,而不是数组:
| 方法 | 别名 | 源码位置(mrblib/lazy.rb) |
|---|---|---|
map |
collect |
L120-L125 |
select |
find_all |
L137-L144 |
reject |
— | L155-L161 |
grep |
— | L172-L178 |
grep_v |
— | L189-L195 |
drop |
— | L206-L215 |
drop_while |
— | L226-L238 |
take |
— | L249-L261 |
take_while |
— | L272-L280 |
flat_map |
collect_concat |
L292-L302 |
zip |
— | L315-L325 |
uniq |
— | L337-L350 |
此外,该实现还额外提供两个便捷方法:
tap_each(L365-L370):对每个元素执行副作用(如日志、调试输出),然后原样透传,非常适合在惰性流水线中观察元素流经各环节的时序;to_enum/enum_for(L93-L106):与Object#to_enum类似,但返回惰性枚举器,可用来把自定义的Enumerable方法包装成"天然保持惰性"的版本。
当所有惰性操作链式挂起后,使用 force(它是 to_a 的别名,见 L382)或 to_a 即可触发求值并取回结果数组;也可以直接迭代(each)或调用 first(n) 等急迫方法,只消费需要的元素。
历史注记:从 doc/mruby3.4.md 可见
grep_v是 mruby 3.4 时代为该 gem 新增的;doc/mruby4.0.md 则记录了Lazy#flat_map对"块返回非可枚举值"场景的修复,这两点都可以在 lazy.rb 的对应实现中找到印证。
工作原理:惰性链是如何被"挂起"的
Enumerator::Lazy 的设计核心是yielder 流水线:每次惰性方法调用都会构造一个新的 Lazy.new(self){ |yielder, val| ... },其中:
Lazy#initialize(L59-L72)接收上游对象obj和一个块;当枚举真正开始时,它遍历obj.each,把每个元素x交给块处理;- 块内部通过
yielder << val(或yielder.yield)决定哪些值继续向下游传递; - 下游方法再次包一层
Lazy.new,把上一次的输出当作输入……如此层层嵌套,直到调用force/to_a/each时才真正"拉取"数据。
例如 select 的实现(L137-L143)本质就是文档注释中描述的模式:
def select(&block)
Lazy.new(self){|yielder, val|
if block.call(val)
yielder << val
end
}
end
这种结构带来的直接收益(README 中也已说明):
- 避免不必要的计算:只有被最终结果消费到的元素才会经过完整流水线;
- 避免不必要的内存分配:中间过程不产生完整数组,每次只处理一个元素;
- 可以处理无限序列:
(1..Float::INFINITY)这类无限范围在急迫模式下根本无法map,但惰性模式下只要take(n)限定了消费数量就能安全运行。
中止机制同样值得注意:take 在取满 n 个元素后通过 raise StopIteration(L249-L261)提前终止上游遍历;Lazy#initialize 中 rescue StopIteration(L69-L70)保证了流水线优雅收尾。take_while、drop_while 则通过内部状态变量(taken、dropping)控制元素放行时机。
使用示例:从无限序列到可观测的求值时序
无限序列:惰性求值的标志性场景
README 给出了最经典的两个示例。急迫写法会尝试创建一个无限数组而无法运行:
# (1..Float::INFINITY).map { |x| x * x }.select { |x| x % 2 == 0 }.take(5).to_a
惰性写法则安全且高效:
p (1..Float::INFINITY).lazy.map { |x| x * x }.select { |x| x % 2 == 0 }.take(5).force
# 输出: [4, 16, 36, 64, 100]
注意这里的执行顺序:1*1=1(非偶数,select 拦截)→ 2*2=4(放行)→ ……
流水线逐元素推进,凑满 5 个偶数平方后即由 take 抛出 StopIteration 中止,根本不会"跑完"无限序列。
观察执行时序:每个元素在 force 时才流过整条链
README 的第二个示例展示了惰性求值的真实时序——所有 puts 都在 force 调用之后发生,且逐元素交替经过各环节:
a = [1, 2, 3, 4, 5]
lazy_sequence = a.lazy.map do |x|
puts "mapping #{x}"
x * 10
end.select do |x|
puts "selecting #{x}"
x > 20
end
puts "Applying force..."
result = lazy_sequence.force
# 输出:
# mapping 1
# selecting 10
# mapping 2
# selecting 20
# mapping 3
# selecting 30
# mapping 4
# selecting 40
# mapping 5
# selecting 50
# Applying force...
p result # 输出: [30, 40, 50]
可以看出:force 之前,lazy_sequence 只是两层 Lazy.new 的嵌套壳;force 之后,1 先被 map、再被 select,然后 2 走同样的路径,完全符合"按需逐元素求值"的语义。若把这种时序观察推广到 tap_each,调试惰性管道会更加方便:
seen = []
result = [1, 2, 3, 4, 5].lazy.tap_each{|x| seen << x }.select{|x| x % 2 == 0 }.force
# result => [2, 4],seen => [1, 2, 3, 4, 5]
(上例取自 test/lazy.rb 的测试用例。)
只取头部:first 是急迫的
first 是急迫方法,无需 force 即可消费有限个元素,例如在无限序列上直接取前几个:
(1..Float::INFINITY).lazy.map {|i| i**2 }.first(3) #=> [1, 4, 9]
经典实战:毕达哥拉斯三元组
源码注释(lazy.rb#L11-L30)提供了一个极具代表性的组合用法——在无限范围内嵌套 flat_map 搜索毕达哥拉斯三元组:
def pythagorean_triples
(1..Float::INFINITY).lazy.flat_map {|z|
(1..z).flat_map {|x|
(x..z).select {|y|
x*x + y*y == z*z
}.map {|y|
[x, y, z]
}
}
}
end
# 展示前 10 个三元组(take 是惰性的,所以需要 force)
p pythagorean_triples.take(10).force
# first 是急迫的,直接取前 10 个
p pythagorean_triples.first(10)
# 展示 z 小于 100 的所有三元组
p pythagorean_triples.take_while { |*, z| z < 100 }.force
这个例子同时演示了:惰性 flat_map 可与"内部仍为急迫"的 select/map 混用(内层作用于有限范围 1..z、x..z,安全可行),而外层流水线保持惰性,从而在无限搜索空间中只计算需要的部分。
方法速查与边界语义
结合 mrblib/lazy.rb 的 call-seq 注释与示例,整理各方法的签名与行为要点:
map/collect、select/find_all、reject、grep、grep_v、take_while、drop_while:均接受块(grep/grep_v接受模式参数并用pattern === val判断),返回惰性枚举器。例如(1..Float::INFINITY).lazy.grep(1..10).force得到[1,2,...,10];(1..Float::INFINITY).lazy.grep_v(2..4).first(3)得到[1, 5, 6]。take(n):取前n个;n == 0时立即返回一个"一枚举就raise StopIteration"的空惰性枚举器(L249-L252)。drop(n):跳过前n个后放行剩余元素。flat_map:块返回的结果若respond_to?(:each)则逐元素放行,否则把结果本身当作单个元素放行(L292-L301)。测试用例 test/lazy.rb#L49-L59 覆盖了"返回数组 / 返回非可枚举 / 返回嵌套数组"三种分支。zip(*args):与一个或多个枚举器并行取元素、打包成数组;若给定块则立即逐组求值(README 与源码注释均强调"带块时 zip 立即枚举",见 L310)。示例:(1..Float::INFINITY).lazy.zip(('a'..'z').cycle).first(3)得到[[1,"a"],[2,"b"],[3,"c"]]。uniq:内部用哈希去重,支持可选块计算去重键(L337-L350)。to_enum(meth, *args):把惰性枚举器按指定方法重新包装;测试 test/lazy.rb#L43-L47 展示了(0..).lazy.to_enum(:each_slice, 2)后配合map惰性取前 4 个切片对乘积的用法。force:即to_a的别名(L382),触发求值并返回数组。
测试验证:源码级行为确认
该 gem 自带测试 mrbgems/mruby-enum-lazy/test/lazy.rb,其中"惰性真实性"测试直接证明了上游只被消费到必要位置:
a = Object.new
def a.each
return to_enum :each unless block_given?
self.b << 10; yield 1 # 每 yield 一次,先向 b 记录一个标记
self.b << 20; yield 2
self.b << 30; yield 3
self.b << 40; yield 4
self.b << 50; yield 5
end
a.b([])
assert_equal [1,2], a.each.lazy.take(2).force
assert_equal [10,20], a.b # 上游只被消费了前两个元素!
同理可验证 select/take 组合只消费到第 4 个元素、take_while 组合只消费到必要位置(test/lazy.rb#L6-L41)。运行整个 gem 的测试可用:
./minirake test MRUBY_CONFIG=minimal
# 或在已配置该 gem 的构建上执行 mruby 测试驱动,运行 test/lazy.rb
精确的测试命令以你当前构建配置为准;该 gem 的测试框架依赖
mruby-test驱动(mrbgems/mruby-test)。
依赖关系与构建配置
依据 mrbgem.rake 与 README,该 gem 依赖两个 mruby 核心 gem:
mruby-enumerator(core):提供Enumerator基类、Yielder、外部迭代(next等,基于 Fiber 实现,见 enumerator.rb);mruby-enum-ext(core):提供Enumerable模块的扩展方法(grep_v、uniq、zip等急迫版本,见 enum.rb),惰性版本正是在其语义之上重定义的。
在构建时启用该 gem 的方式(任选其一):
- 使用 stdlib gembox:
mruby-enum-lazy已包含在 mrbgems/stdlib.gembox 中(注释明确"Use Enumerator::Lazy class (require mruby-enumerator)"),而defaultgembox 又包含stdlib(见 mrbgems/default.gembox),所以默认构建即带Enumerator::Lazy; - 在自定义 build_config 中显式添加:在
MRuby::Build配置块里加入conf.gem :core => "mruby-enum-lazy",例如 build_config/playstationportable.rb、build_config/gameboyadvance.rb 等嵌入式构建均采用此方式;也可以像 build_config/milkv_duo.rb、build_config/luckfox_pico.rb 那样直接conf.gem 'mrbgems/mruby-enum-lazy/'。
小结
mruby-enum-lazy 以极小的代码量(一个 lazy.rb 文件)为 mruby 带来了与 CRuby 语义对齐的 Enumerator::Lazy 惰性求值体系。其核心价值可以概括为三点:
- 无限序列可计算:借助
take/take_while/first的按需消费,打破"集合必须有限"的限制; - 链式管道零中间数组:元素逐个流过各变换环节,内存开销与计算量都只与"实际消费量"成正比;
- 与急迫方法无缝混用:
force/to_a随时可以"落袋为安",first等急迫方法天然可作用在惰性链末端。
对于嵌入式或资源受限场景下的 mruby 程序,在需要处理大规模数据流、日志流或无限生成器时,Enumerator::Lazy 是一个值得优先考虑的标准库级方案——它已被收录于默认构建,开箱即用。