249                     }
 250                 };
 251             }
 252         };
 253     }
 254 
 255     @Override
 256     public final DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
 257         return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
 258                                         StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
 259             @Override
 260             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
 261                 return new Sink.ChainedDouble<Double>(sink) {
 262                     @Override
 263                     public void begin(long size) {
 264                         downstream.begin(-1);
 265                     }
 266 
 267                     @Override
 268                     public void accept(double t) {

 269                         // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
 270                         DoubleStream result = mapper.apply(t);
 271                         if (result != null)
 272                             result.sequential().forEach(i -> downstream.accept(i));
 273                     }

 274                 };
 275             }
 276         };
 277     }
 278 
 279     @Override
 280     public DoubleStream unordered() {
 281         if (!isOrdered())
 282             return this;
 283         return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE, StreamOpFlag.NOT_ORDERED) {
 284             @Override
 285             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
 286                 return sink;
 287             }
 288         };
 289     }
 290 
 291     @Override
 292     public final DoubleStream filter(DoublePredicate predicate) {
 293         Objects.requireNonNull(predicate);

 249                     }
 250                 };
 251             }
 252         };
 253     }
 254 
 255     @Override
 256     public final DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
 257         return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
 258                                         StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
 259             @Override
 260             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
 261                 return new Sink.ChainedDouble<Double>(sink) {
 262                     @Override
 263                     public void begin(long size) {
 264                         downstream.begin(-1);
 265                     }
 266 
 267                     @Override
 268                     public void accept(double t) {
 269                         try (DoubleStream result = mapper.apply(t)) {
 270                             // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it

 271                             if (result != null)
 272                                 result.sequential().forEach(i -> downstream.accept(i));
 273                         }
 274                     }
 275                 };
 276             }
 277         };
 278     }
 279 
 280     @Override
 281     public DoubleStream unordered() {
 282         if (!isOrdered())
 283             return this;
 284         return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE, StreamOpFlag.NOT_ORDERED) {
 285             @Override
 286             Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
 287                 return sink;
 288             }
 289         };
 290     }
 291 
 292     @Override
 293     public final DoubleStream filter(DoublePredicate predicate) {
 294         Objects.requireNonNull(predicate);