我在使用 Ruby 时遇到了初期问题，涉及创建单向、惰性求值、可能无限的迭代器。基本上，我尝试像使用 Haskell 列表一样使用 Ruby，并在较小程度上使用 Python 生成器。

并不是我不理解它们本身；而是我不理解它们。我只是不知道如何像其他语言一样随意使用它们，而且我也不确定 Ruby 中的哪些方法会在我背后将它们变成数组，从而不必要地将整个序列卸载到内存中。

是的，我一直在研究 Ruby 引用手册。实际上，专心地进行了半个小时。或许显然不是。

例如，如果我要实现一个卡片组，它在 Python 中看起来像这样(未经测试):

# Python 3

from itertools import chain, count

face_ranks =
    dict(
        zip(
            ('jack', 'queen', 'king', 'ace'),
            count(11)))

sorted_deck =
    map(
        lambda suit:
            map(
                lambda rank:
                    {
                        'rank' : rank,
                        'suit' : suit
                    },
                chain(
                    range(2, 11),
                    face_ranks.keys())),
        ('clubs', 'diamonds', 'hearts', 'spades'))

那么，我如何在 Ruby 中做到这一点，完全避免数组？请注意，据我所知，上面的代码只使用了元组和生成器:在任何时候都不会像我使用数组那样将整个序列转储到内存中。上面的代码我可能是错的，但你得到了我想要的。

如何链接迭代器(如 Python 的 chain())？如何生成无限范围的迭代器(如 Python 的 count())？如何将数组添加到迭代器(例如将元组传递给 Python 的 chain())而不在此过程中将整个事物转换为数组？

我见过解决方案，但它们涉及阵列或不必要的复杂性，例如光纤。

在 Python 中，我可以像数组一样简单地操作和抛出迭代器。我几乎可以像对待 Haskell 列表一样对待它们，这是我最熟悉的，也是我在编码时真正考虑的。我对 Ruby 数组不满意，这就是为什么我寻求有关其替代方案的帮助。

我已经设法在 Internet 上找到有关它的信息 block ，但我找不到任何涵盖 Ruby 中此类数据结构的基本操作的信息？有帮助吗？

最佳答案

Ruby 似乎没有很多内置方法来完成您想用枚举器做的不同事情，但您可以创建自己的方法。这就是我在这里所做的，使用 Ruby 1.9:

iter.rb

def get_enums_from_args(args)
  args.collect { |e| e.is_a?(Enumerator) ? e.dup : e.to_enum }
end

def build(y, &block)
  while true
    y << (begin yield; rescue StopIteration; break; end)
  end
end

def zip(*args)
  enums = get_enums_from_args args
  Enumerator.new do |y|
    build y do
      enums.collect { |e| e.next }
    end
  end
end

def chain(*args)
  enums = get_enums_from_args args
  Enumerator.new do |y|
    enums.each do |e|
      build y do
        e.next
      end
    end
  end
end

def multiply(*args)
  enums = get_enums_from_args args
  duped_enums = enums.collect { |e| e.dup }
  Enumerator.new do |y|
    begin
      while true
        y << (begin; enums.collect { |e| e.peek }; rescue StopIteration; break; end )

        index = enums.length - 1
        while true
          begin
            enums[index].next
            enums[index].peek
            break
          rescue StopIteration
            # Some iterator ran out of items.

            # If it was the first iterator, we are done,
            raise if index == 0

            # If it was a different iterator, reset it
            # and then look at the iterator before it.
            enums[index] = duped_enums[index].dup
            index -= 1
          end
        end
      end
    rescue StopIteration
    end
  end
end

然后我使用 rspec 编写了一个规范来测试函数并演示它们的作用:

iter_spec.rb:

require_relative 'iter'

describe "zip" do
  it "zips together enumerators" do
    e1 = "Louis".chars
    e2 = "198".chars
    zip(e1,e2).to_a.should == [ ['L','1'], ['o','9'], ['u','8'] ]
  end

  it "works with arrays too" do
    zip([1,2], [:a, nil]).to_a.should == [ [1,:a], [2,nil] ]
  end
end

describe "chain" do
  it "chains enumerators" do
    e1 = "Jon".chars
    e2 = 0..99999999999
    e = chain(e1, e2)
    e.next.should == "J"
    e.next.should == "o"
    e.next.should == "n"
    e.next.should == 0
    e.next.should == 1
  end
end

describe "multiply" do
  it "multiplies enumerators" do
    e1 = "ABC".chars
    e2 = 1..3
    multiply(e1, e2).to_a.should == [["A", 1], ["A", 2], ["A", 3], ["B", 1], ["B", 2], ["B", 3], ["C", 1], ["C", 2], ["C", 3]]
  end

  it "is lazily evalutated" do
    e1 = 0..999999999
    e2 = 1..3
    e = multiply(e1, e2)
    e.next.should == [0, 1]
    e.next.should == [0, 2]
    e.next.should == [0, 3]
    e.next.should == [1, 1]
    e.next.should == [1, 2]
  end

  it "resulting enumerator can not be cloned effectively" do
    ranks = chain(2..10, [:jack, :queen, :king, :ace])
    suits = [:clubs, :diamonds, :hearts, :spades]
    cards = multiply(suits, ranks)
    c2 = cards.clone
    cards.next.should == [:clubs, 2]
    c2.next.should == [:clubs, 2]
    c2.next.should == [:clubs, 3]
    c2.next.should == [:clubs, 4]
    c2.next.should == [:clubs, 5]
    cards.next.should == [:clubs, 6]
  end

  it "resulting enumerator can not be duplicated after first item is evaluated" do
    ranks = chain(2..10, [:jack, :queen, :king, :ace])
    suits = [:clubs, :diamonds, :hearts, :spades]
    cards = multiply(ranks, suits)
    cards.peek
    lambda { cards.dup }.should raise_error TypeError
  end
end

如上面的规范所示，这些方法使用惰性求值。

此外，这里定义的zip、chain 和multiply 函数的主要弱点是生成的枚举数不能轻易复制或克隆，因为我们没有编写任何代码来复制这些新枚举器所依赖的枚举参数。您可能需要创建 Enumerator 的子类或创建一个包含 Enumerable 模块或类似模块的类，以使 dup 正常工作。

关于arrays - Ruby:操纵迭代器？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6977092/