从第一个元素创建一个可枚举的 ruby​​，以及一个从前一个元素获取下一个元素的函数

Question

在 Scala 中，您可以从其第一个元素定义一个流，以及从前一个元素获取下一个元素的函数；

Stream.iterate(1)(x => 2 * x + 1)

在 Ruby 中是否存在这样的东西？

我们当然可以手卷它-

 module Kernel
   def stream
     Enumerator.new do |y|
       that = self
       while true
         y << that
         that = yield that
       end
     end
   end
 end

但它是惯用的吗？已经有这样的东西了吗？

Answer 1

您要询问的内容称为unfold（在scala 中称为Stream.iterate），或者更一般地称为anamorphism。它是fold（在ruby 中称为Enumerable#inject）又名catamorphism 的精确类别理论对偶。

已经有类似的东西了吗？

不幸的是，核心或标准库中没有执行此功能的方法。

但它是惯用的吗？

我可能会将其设为Enumerator 的单例方法并使用Kernel#loop 而不是while true，但仅此而已。否则，是的，您的代码非常地道。

当我们这样做的时候，让我们称之为unfold：

def Enumerator.unfold(start)
  new do |y|
    loop do
      y << start
      start = yield start
    end
  end
end

Answer 2

我不知道有一种公认的惯用方式。 由于您的代码似乎无法生成您喜欢的内容，因此我将举例说明如何实现它。

您可以使用Fiber 创建外部迭代展开，如下所示：

def stream(init, &block)
  Fiber.new do 
    memo = init
    loop do
      Fiber.yield memo
      memo = block.call memo
    end
  end
end

a = stream(1){ |x| 2 * x + 1 }

a.resume  # => 1
a.resume  # => 3
a.resume  # => 7
a.resume  # => 15

如果您更喜欢拥有所有超能力的Enumerator::Lazy，请考虑：

def stream2(init, &block)
  Enumerator.new do |yielder| 
    memo = init
    loop do 
      yielder << memo
      memo = block.call memo 
    end 
  end.lazy
end

a2 = stream2(1){ |x| 2 * x + 1 }

a2.next  # => 1
a2.next  # => 3
a2.next  # => 7

a2.take(10).force  # => [1, 3, 7, 15, 31, 63, 127, 255, 511, 1023]

其行为与此相同：

def stream3(init, &block)
  memo = init
  (1..Float::INFINITY).lazy.map{ |_| memo = block.call(memo) }
end

最后一个可能是最惯用的，并且最好地隐藏了枚举的内部结构。但是，我个人不喜欢stream3，因为它产生的数字只是为了丢弃它们。

HTH

Answer 3

在 Ruby 中，您将使用 Enumerable#inject:

[7, 8, 9].inject(1){ |carry, item| 2 * carry + item }

块的返回值将作为进位变量的下一个值。