@SuppressWarnings("unchecked") @Override default <C> Map<C, Seq<T>> groupBy(Function<? super T, ? extends C> classifier) { return io.vavr.collection.Collections.groupBy(values(), classifier, Stream::ofAll); }
/** * Traverses this tree values in a specific {@link Order}. * * @param order A traversal order * @return A new Iterator */ default io.vavr.collection.Iterator<T> iterator(Order order) { return values(order).iterator(); }
@Override default Seq<T> retainAll(Iterable<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); return values().retainAll(elements); }
@Override default Seq<T> takeUntil(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return values().takeUntil(predicate); }
@Override default Seq<T> takeWhile(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); return values().takeWhile(predicate); }
@Override default Seq<T> distinct() { return values().distinct(); }
@Override default io.vavr.collection.Iterator<T> iterator() { return values().iterator(); }
@Override default Seq<T> init() { if (isEmpty()) { throw new UnsupportedOperationException("init of empty tree"); } else { return values().init(); } }
@Override default Seq<T> tail() { if (isEmpty()) { throw new UnsupportedOperationException("tail of empty tree"); } else { return values().tail(); } }
@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> 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> 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> take(int n) { if (isEmpty()) { return Stream.empty(); } else { return values().take(n); } }
@Override default Seq<T> dropRight(int n) { if (n >= length()) { return Stream.empty(); } else { return values().dropRight(n); } }
@Override default Seq<T> drop(int n) { if (n >= length()) { return Stream.empty(); } else { return values().drop(n); } }
@Override default Seq<T> takeRight(int n) { if (isEmpty()) { return Stream.empty(); } else { return values().takeRight(n); } }
@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); } }
@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); } }