Question

关于创建单向，延迟评估，可能无限的迭代器，我遇到了Ruby的问题。基本上，我正在尝试使用Ruby，就像我使用Haskell列表，以及在较小程度上使用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的链（））而不将整个过程转换为过程中的数组？

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

在Python中，我可以像数组一样简单地操作和抛出迭代器。我几乎可以把它们当作Haskell列表来对待，我最熟悉的就是它，而且在编码时我的想法就是这样。我对Ruby数组感到不舒服，这就是为什么我寻求其替代品的帮助。

我已经设法在互联网上获取有关它的信息，但我找不到任何涵盖Ruby中这些数据结构的基本操作？有什么帮助吗？

Answer 1

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正常工作。

Answer 2

看起来你正在避免出现性能焦虑的Ruby数组，这可能是由于你在其他语言中使用数组的经验。你无需避免使用Ruby数组 - 它们是你在Ruby中获得元组最接近的东西。

foo = 1, 2, 3, 4
foo.class       #=> Array

看起来你正在寻找一个代替发电机的范围：

range = 1..4
range.class     #=> Range
range.count     #=> 4

('a'..'z').each { |letter| letter.do_something }

范围不会转换为数组，但它包含Enumerable，因此您可以使用所有常规枚举器。至于循环/迭代 - Ruby中的本机循环是通过Enumerable。 for i in group实际上是枚举器循环的语法糖（如.each）。可枚举的方法通常会返回发件人，因此您可以链接它们：

(1..10).map { |n| n * 2 }.each { |n| print "##{n}" }
# outputs #2#4#6#8#10#12#14#16#18#20
# returns an array:
#=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

我想为您提供有关Python»Ruby等效的更具体的答案，但我不熟悉Python。

更新

您可以将范围压缩成一个嵌套数组，如下所示：

(1..26).zip('a'..'z') #=> [[1, 'a'], [2, 'b'], ...]

...但是范围不可变。您可以使用(1..5).to_a将范围转换为数组，也可以像上面显示的那样迭代它。如果您要测试多个已定义的数据范围，则可以使用几个范围和地图：

allowed = 'a'..'z', 1..100
input = # whatever
allowed.each do |range|
  return false unless range.cover? input
end

当然，您总是可以使用带范围的枚举器来“生成”动态值。

Answer 3

Ruby中最接近的等价物是Enumerator。它可以让你做懒惰的生成器。

Ruby：操纵迭代器？

3 个答案:

更新