Stack overflow when joining stream of empty streams

[l1cache]

    public void test() {
        Stream.join(nils());
    }

    Stream<Stream<Integer>> nils() {
        return Stream.cons(Stream.nil(), this::nils);
    }

This code produces StackOverflowError cause append function recursively evaluates all nil streams while looking for head.
I only came up with ugly looking while inside bind function which produces stream's head on constant stack.
Any ideas?

[l1cache]

I could think of this solution, but it looks like huge overkill:

  public final <B> Stream<B> bind(final F<A, Stream<B>> f) {
    return foldRight2((h, t) -> {
      Stream<B> f1 = f.f(h);
      return Option.iif(!f1.isEmpty(), () -> f1.append(t));
    }, Stream.nil());
  }

  public final <B> B foldRight2(final F2<A, P1<B>, Option<B>> f, final B b) {
    return Option.somes(map((h, t) -> f.f(h, P.lazy(() -> t._1().foldRight2(f, b))))).orHead(() -> b);
  }

  public final <B> Stream<B> map(final F2<A, P1<Stream<A>>, B> f) {
    return isEmpty() ? nil() : cons(f.f(head(), tail()), () -> tail()._1().map(f));
  }

[jbgi]

Yeah, there is a laziness issue with Stream: both head and tail should be part of a lazy thunk. Not only the tail. And then reduction to "weak head normal form" should be properly trampolined. I will work an a redesign shortly. I have worked on a prototype of such design in the past. Thanks for reporting the issue and providing a motivation to finish the work!