过滤功能不懒惰

functional-programming lazy-evaluation lambda java java-8

2022-09-04 22:41:22

我正在制作我自己的Java流库版本，以此为乐。这是我的班级签名：

class Stream<T> {
  Supplier<T> head;
  Supplier<Stream<T>> tail;
  ...
}

另外，我写了一个基本的无限流迭代器，它将基于给定的函数生成一个无限列表：

  public static <T> Stream<T> iterate(T first, Function<T, T> f) {
    return new Stream<T>(
            () -> first,
            () -> {
              T nextElem = f.apply(first);
              if (nextElem == null) {
                return generate(() -> null);
              } else {
                return iterate(nextElem, f);
              }
            }
    );
  }

该函数是迭代的一种特殊情况，它永远重复给定的元素。在上面的函数中，我生成了一个无限序列，以指示流的结束（我不认为我会在流中存储空值）。generatenull

然后，我编写了一个 reduce 函数，其中 reduce 函数在其第二个参数上是惰性的：

  public <U> U reduce(U acc, Function<T, Function<Supplier<U>, U>> f) {
    System.out.println("REDUCE CALL");
    T elem = head.get();
    if (elem != null) {
      return f.apply(elem).apply(() -> this.tail.get().reduce(acc, f));
    } else {
      return acc;
    }
  }

在 reduce 函数的基础上，我编写了 filter 函数。

  public Stream<T> filter(Predicate<T> p) {
    System.out.println("FILTER");
    return reduce(generate(() -> null), elem -> acc -> {
      if (p.test(elem)) {
        return new Stream<>(
                () -> elem,
                () -> acc.get()
        );
      } else {
        return acc.get();
      }
    });
  }

最后，我继续使用我自己的 Stream 类：

  public static void main(String[] args) {
    Stream<Integer> ilist =
            Stream
              .iterate(1, x -> x + 1)
              .filter(x -> x >= 5);
  }

但过滤器并不懒惰！从下面给出的输出来看，我认为过滤器会评估元素，直到找到与给定谓词匹配的元素。

FILTER
REDUCE CALL
REDUCE CALL
REDUCE CALL
REDUCE CALL
REDUCE CALL

我的代码出了什么问题，如何使我的筛选器函数再次变懒？

更新：根据Sweeper的评论，我在不使用reduce的情况下再次尝试过滤功能。

  public Stream<T> filter2(Predicate<T> p) {
    System.out.println("FILTER2");
    T elem = head.get();
    if (elem == null) {
      return generate(() -> null);
    } else {
      if (p.test(elem)) {
        return new Stream<>(
                () -> elem,
                () -> this.tail.get().filter2(p)
        );
      } else {
        return this.tail.get().filter2(p);
      }
    }
  }

但是，此函数也不是懒惰的。我使用的主要函数的输出如下：filter2

FILTER2
FILTER2
FILTER2
FILTER2
FILTER2

我该如何解决这个问题，有没有办法通过懒惰的减少来实现懒惰的过滤器？

致谢：这个练习和上述函数的实现受到Chiusano和Bjarnason的《Scala中的函数式编程》一书的启发。

答案 1

在你写的没有的版本中，元素存在但不满足谓词的情况不是懒惰。而不是像在其他情况下那样将递归调用包装在供应商 lambda 中，而是急切地获取尾部并立即对其进行筛选。reduce

public Stream<T> filter2(Predicate<T> p) {
    System.out.println("FILTER2");
    T elem = head.get();
    if (elem == null) {
        return generate(() -> null);
    } else {
        if (p.test(elem)) {
            return new Stream<>(
                () -> elem,
                () -> this.tail.get().filter2(p)
            );
        } else {
            return this.tail.get().filter2(p); // <- not lazy!
        }
    }
}

您需要的是一种创建流的方法，以便将其是否为空的决定推迟到以后。

public class Stream<T> {
    // private constructor(s)

    public static <T> Stream<T> empty() { /* ... */ }

    public static <T> Stream<T> cons(Supplier<T> head, Supplier<Stream<T> tail) { /* ... */ }

    public static <T> Stream<T> lazy(Supplier<Stream<T>> stream) { /* ... */ }

    public Stream<T> filter(Predicate<T> p) {
        if ( /* this stream is empty */ ) {
            return Stream.empty();
        } else if ( /* head element satisfies predicate */ ) {
            // lazily filter tail, cons head element
        } else {
            return Stream.lazy(() -> this.tail.get().filter(p));
        }
    }
}

沿着这些路线的东西。

答案 2