How is this Eratosthenes Sieve implementation is working internally?

Question

I found this code that seems to be the non-optimal version of the Sieve of Erastothenes, it gets the N first prime numbers into an array.

private IntPredicate p = x -> true;

private int[] primes(int n) {
    
    return IntStream.iterate(2, i -> i + 1)
        .filter(x -> p.test(x))
        .peek(i -> p = p.and(k -> k % i != 0))
        .limit(n)
        .toArray();
}

What's happening internally with the IntPredicate?

Answer 1

This code produces an aggregate Predicate via IntPredicate.and() method, which would work this way:

p = x -> true; // for first stream element `2` - 
               //   which passes the predicate p

// Predicate p is being reassigned while
// peek() sees the element `2`, to
p = x -> true && x % 2 != 0

// The next stream element `3` passes the updated predicate
// And the predicate is being reassigned again while
// peek() sees the element `3` to

p = x -> true && x % 2 != 0 && x % 3 != 0

// And so on...

So every element which successfully passes the filter results in a new condition being appended to the current predicate via "logical AND" &&.

At the end of the stream execution, the predicate would consist of conditions that check the given number against all the prime number from that would be present in the result.

Note that this hacky implementation is broken:

peek() is an operation which was introduced exclusively to support debugging. It's not meant to be used for performing actions that could affect the result of the execution. peek gives no guaranty regarding the order in which it will be called while executing in parallel, and in certain cases can be optimized away.