Java streams lazy vs fusion vs short-circuiting

As for fusion. Let’s imagine here’s a map operation:

.map(x -> x.squash())

Map

It’s stateless and it just transforms any input according to the specified algorithm (in our case squashes them). Now the filter operation:

.filter(x -> x.getColor() != YELLOW)

Filter

It’s also stateless and it just removes some elements (in our case yellow ones). Now let’s have a terminal operation:

.forEach(System.out::println)

Display

It just displays the input elements to the terminal. The fusion means that all intermediate stateless operations are merged with terminal consumer into single operation:

.map(x -> x.squash())
.filter(x -> x.getColor() != YELLOW)
.forEach(System.out::println)

Fuse

The whole pipeline is fused into single Consumer which is connected directly to the source. When every single element is processed, the source spliterator just executes the combined consumer, the stream pipeline does not intercept anything and does not perform any additional bookkeeping. That’s fusion. Fusion does not depend on short-circuiting. It’s possible to implement streams without fusion (execute one operation, take the result, execute the next operation, taking the control after each operation back to the stream engine). It’s also possible to have fusion without short-circuiting.

Leave a Comment