如何使用定义的生成器构建惰性列表，是否有“获取”替代方案？

Question

我正在阅读懒惰列表上的perl6intro，它让我对某些事情感到困惑。

举个例子：

sub foo($x) {
  $x**2
}

my $alist = (1,2, &foo ... ^ * > 100);

将给我（1 2 4 16 256），它将使相同的数字平方，直到超过100。我想要这个给我（14 9 16 25….），因此不是将同一个数平方，而是将一个数x推进1（或另一个给定的“步长”）、foo x等等。

在这种特殊情况下，有可能实现这一点吗？

关于懒惰列表，我的另一个问题是：在Haskell中，有一个takeWhile函数，Perl6中是否存在类似的东西？




Answer 1

我要这个给我（1 4 9 16 25 .. )

my @alist = {(++$)²} ... Inf;
say @alist[^10]; # (1 4 9 16 25 36 49 64 81 100)

{...}是任意代码块。当用作...序列运算符的LHS时，它会为序列的每个值调用。

（…）²计算为paren内表达式的平方。（我本可以写下同样的意思。）

$通过将预增量（添加一个）与$变量相结合来返回1, 2, 3, 4, 5, 6...。

在Haskell中，有一个获取函数，Perl6中是否存在类似的东西？

将上述序列中的Inf替换为所需的结束条件：

my @alist = {(++$)²} ... * > 70;    # stop at step that goes past 70
say @alist; # [1 4 9 16 25 36 49 64 81]

my @alist = {(++$)²} ...^ * > 70;   # stop at step before step past 70
say @alist; # [1 4 9 16 25 36 49 64]

注意， 和<代码>^ 序列运算符的变体提供了停止条件的两种变体。我注意到，在您最初的问题中，您有<代码>…^*

Answer 2

匿名用户

我要这个给我（1 4 9 16 25 .. )

获得该序列的最简单方法是：

my @a = (1..*).map(* ** 2);  # using a Whatever-expression
my @a = (1..*).map(&foo);    # using your `foo` function

...或者如果您更喜欢以类似于Haskell/Python列表理解的方式编写它：

my @a = ($_ ** 2 for 1..*);  # using an in-line expression
my @a = (foo $_ for 1..*);   # using your `foo` function

虽然可以不厌其烦地通过<代码>表达这个序列 运算符（正如Brad Gilbert的答案和raiph的答案所证明的那样），它实际上没有意义，因为该运算符的目的是生成序列，其中每个元素都是使用一致规则从之前的元素派生的。

为每项工作使用最佳工具：

>

如果序列最容易表示为闭合公式（例如，平方序列）：
使用映射或表示。

Answer 3

下面是如何编写Perl

sub take-while ( &condition, Iterable \sequence ){
  my \iterator = sequence.iterator;

  my \generator = gather loop {
    my \value = iterator.pull-one;
    last if value =:= IterationEnd or !condition(value);
    take value;
  }

  # should propagate the laziness of the sequence
  sequence.is-lazy
  ?? generator.lazy
  !! generator
}

我可能还应该展示droptime的实现。

sub drop-while ( &condition, Iterable \sequence ){
  my \iterator = sequence.iterator;

  GATHER: my \generator = gather {

    # drop initial values
    loop {
      my \value = iterator.pull-one;

      # if the iterator is out of values, stop everything
      last GATHER if value =:= IterationEnd;

      unless condition(value) {
        # need to take this so it doesn't get lost
        take value;

        # continue onto next loop
        last;
      }
    }

    # take everything else
    loop {
      my \value = iterator.pull-one;
      last if value =:= IterationEnd;
      take value
    }
  }

  sequence.is-lazy
  ?? generator.lazy
  !! generator
}

这些只是简单的实用例子。

可以说，这些值得作为方法添加到列表/可迭代对象中。

您可以（但可能不应该）使用序列生成器语法实现这些。

sub take-while ( &condition, Iterable \sequence ){
  my \iterator = sequence.iterator;
  my \generator = { iterator.pull-one } …^ { !condition $_ }
  sequence.is-lazy ?? generator.lazy !! generator
}

sub drop-while ( &condition, Iterable \sequence ){
  my \end-condition = sequence.is-lazy ?? * !! { False };
  my \iterator = sequence.iterator;

  my $first;
  loop {
    $first := iterator.pull-one;
    last if $first =:= IterationEnd;
    last unless condition($first);
  }

  # I could have shoved the loop above into a do block
  # and placed it where ｢$first｣ is below

  $first, { iterator.pull-one } … end-condition
}

如果它们被添加到Perl中

直接实现您的要求如下：

do {
  my $x = 0;
  { (++$x)² } …^ * > 100
}

这可以通过状态变量实现：

{ ( ++(state $x = 0) )² } …^ * > 100

并且在声明之外不使用的状态变量不需要名称。
（标量变量以未定义的任何开始，在数字上下文中变为0）

{ (++( $ ))² } …^ * > 100
{ (++$)² } …^ * > 100

如果需要初始化匿名状态变量，可以使用定义的-or运算符//与相等的元运算符=相结合。

{ (++( $ //= 5))² } …^ * > 100

在一些简单的情况下，您不必告诉序列生成器如何计算下一个值<在这种情况下，也可以简化结束条件。

say 1,2,4 ...^ 100
# (1 2 4 8 16 32 64)

唯一可以安全简化结束条件的其他时间是，如果您知道它将在值上停止。

say 1, { $_ * 2 } ... 64;
# (1 2 4 8 16 32 64)

say 1, { $_ * 2 } ... 3;
# (1 2 4 8 16 32 64 128 256 512 ...)