/** * Alias for {@link Stream#empty()} * * @param <T> Component type of element. * @return A singleton instance of empty {@link Stream} */ public static <T> Stream<T> Stream() { return Stream.empty(); }
/** * Converts this to a {@link Stream}. * * @return A new {@link Stream}. */ default Stream<T> toStream() { return ValueModule.toTraversable(this, Stream.empty(), Stream::of, Stream::ofAll); }
@Override default Iterator<Stream<T>> crossProduct(int power) { return io.vavr.collection.Collections.crossProduct(Stream.empty(), this, power); }
@SuppressWarnings("unchecked") @Override default Tuple2<Seq<T>, Seq<T>> span(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return Tuple.of(Stream.empty(), Stream.empty()); } else { return (Tuple2<Seq<T>, Seq<T>>) values().span(predicate); } }
@SuppressWarnings("unchecked") @Override default Tuple2<Seq<T>, Seq<T>> partition(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return Tuple.of(Stream.empty(), Stream.empty()); } else { return (Tuple2<Seq<T>, Seq<T>>) values().partition(predicate); } }
static <T> Stream<Node<T>> traverseLevelOrder(Node<T> node) { Stream<Node<T>> result = Stream.empty(); final java.util.Queue<Node<T>> queue = new java.util.LinkedList<>(); queue.add(node); while (!queue.isEmpty()) { final Node<T> next = queue.remove(); result = result.prepend(next); queue.addAll(next.getChildren().toJavaList()); } return result.reverse(); }
@Override default <U> Seq<T> distinctBy(Function<? super T, ? extends U> keyExtractor) { Objects.requireNonNull(keyExtractor, "keyExtractor is null"); if (isEmpty()) { return Stream.empty(); } else { return values().distinctBy(keyExtractor); } }
@Override default Seq<T> dropWhile(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return Stream.empty(); } else { return values().dropWhile(predicate); } }
@Override default Seq<T> reject(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return Stream.empty(); } else { return values().reject(predicate); } }
@Override default Seq<T> distinctBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator, "comparator is null"); if (isEmpty()) { return Stream.empty(); } else { return values().distinctBy(comparator); } }
@Override default Seq<T> filter(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return Stream.empty(); } else { return values().filter(predicate); } }
@Override default Seq<T> drop(int n) { if (n >= length()) { return Stream.empty(); } else { return values().drop(n); } }
@Override default Seq<T> dropRight(int n) { if (n >= length()) { return Stream.empty(); } else { return values().dropRight(n); } }
@Override default Seq<T> take(int n) { if (isEmpty()) { return Stream.empty(); } else { return values().take(n); } }
@Override default Seq<T> takeRight(int n) { if (isEmpty()) { return Stream.empty(); } else { return values().takeRight(n); } }
static <T> Stream<Node<T>> traversePostOrder(Node<T> node) { return node .getChildren() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traversePostOrder(child))) .append(node); }
@Override default Stream<T> slice(int beginIndex, int endIndex) { if (beginIndex >= endIndex || isEmpty()) { return empty(); } else { final int lowerBound = Math.max(beginIndex, 0); if (lowerBound == 0) { return cons(head(), () -> tail().slice(0, endIndex - 1)); } else { return tail().slice(lowerBound - 1, endIndex - 1); } } }
static <T> Stream<Stream<T>> apply(Stream<T> elements, int k) { if (k == 0) { return Stream.of(Stream.empty()); } else { return elements.zipWithIndex().flatMap( t -> apply(elements.drop(t._2 + 1), (k - 1)).map((Stream<T> c) -> c.prepend(t._1)) ); } } }
@Override default Stream<T> take(int n) { if (n < 1 || isEmpty()) { return empty(); } else if (n == 1) { return cons(head(), Stream::empty); } else { return cons(head(), () -> tail().take(n - 1)); } }
static <T> Stream<Node<T>> traverseInOrder(Node<T> node) { if (node.isLeaf()) { return Stream.of(node); } else { final io.vavr.collection.List<Node<T>> children = node.getChildren(); return children .tail() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traverseInOrder(child))) .prepend(node) .prependAll(traverseInOrder(children.head())); } }