/** * Pushes the given elements on top of this List. A List has LIFO order, i.e. the last of the given elements is * the first which will be retrieved. * * @param elements An Iterable of elements, may be empty * @return a new {@code List} instance, containing the new elements on top of this List * @throws NullPointerException if elements is null */ default List<T> pushAll(Iterable<T> elements) { Objects.requireNonNull(elements, "elements is null"); List<T> result = this; for (T element : elements) { result = result.prepend(element); } return result; }
/** * Enqueues a new element. * * @param element The new element * @return a new {@code Queue} instance, containing the new element */ @Override public Queue<T> enqueue(T element) { return new Queue<>(front, rear.prepend(element)); }
@Override public Queue<T> prepend(T element) { return new Queue<>(front.prepend(element), rear); }
@Override default <U> List<U> map(Function<? super T, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); List<U> list = empty(); for (T t : this) { list = list.prepend(mapper.apply(t)); } return list.reverse(); }
@Override default <U> List<U> flatMap(Function<? super T, ? extends Iterable<? extends U>> mapper) { Objects.requireNonNull(mapper, "mapper is null"); List<U> list = empty(); for (T t : this) { for (U u : mapper.apply(t)) { list = list.prepend(u); } } return list.reverse(); }
@Override default List<T> append(T element) { return foldRight(of(element), (x, xs) -> xs.prepend(x)); }
@Override default Tuple2<List<T>, List<T>> partition(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); List<T> left = empty(), right = empty(); for (T t : this) { if (predicate.test(t)) { left = left.prepend(t); } else { right = right.prepend(t); } } return Tuple.of(left.reverse(), right.reverse()); }
@Override default <T1, T2> Tuple2<List<T1>, List<T2>> unzip( Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper) { Objects.requireNonNull(unzipper, "unzipper is null"); List<T1> xs = Nil.instance(); List<T2> ys = Nil.instance(); for (T element : this) { final Tuple2<? extends T1, ? extends T2> t = unzipper.apply(element); xs = xs.prepend(t._1); ys = ys.prepend(t._2); } return Tuple.of(xs.reverse(), ys.reverse()); }
@Override default <T1, T2, T3> Tuple3<List<T1>, List<T2>, List<T3>> unzip3( Function<? super T, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper) { Objects.requireNonNull(unzipper, "unzipper is null"); List<T1> xs = Nil.instance(); List<T2> ys = Nil.instance(); List<T3> zs = Nil.instance(); for (T element : this) { final Tuple3<? extends T1, ? extends T2, ? extends T3> t = unzipper.apply(element); xs = xs.prepend(t._1); ys = ys.prepend(t._2); zs = zs.prepend(t._3); } return Tuple.of(xs.reverse(), ys.reverse(), zs.reverse()); }
@Override default List<T> replaceAll(T currentElement, T newElement) { List<T> result = Nil.instance(); boolean changed = false; for (List<T> list = this; !list.isEmpty(); list = list.tail()) { final T head = list.head(); if (Objects.equals(head, currentElement)) { result = result.prepend(newElement); changed = true; } else { result = result.prepend(head); } } return changed ? result.reverse() : this; }
static <T> Tuple2<List<T>, List<T>> splitByPredicateReversed(List<T> source, Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); List<T> init = Nil.instance(); List<T> tail = source; while (!tail.isEmpty() && !predicate.test(tail.head())) { init = init.prepend(tail.head()); tail = tail.tail(); } return Tuple.of(init, tail); } }
@Override public io.vavr.collection.List<T> toList() { io.vavr.collection.List<T> results = io.vavr.collection.List.empty(); for (PriorityQueue<T> queue = this; !queue.isEmpty(); ) { final Tuple2<T, PriorityQueue<T>> dequeue = queue.dequeue(); results = results.prepend(dequeue._1); queue = dequeue._2; } return results.reverse(); }
@Override default List<T> takeWhile(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); List<T> result = Nil.instance(); for (List<T> list = this; !list.isEmpty() && predicate.test(list.head()); list = list.tail()) { result = result.prepend(list.head()); } return result.length() == length() ? this : result.reverse(); }
@Override default List<T> removeFirst(Predicate<T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); List<T> init = empty(); List<T> tail = this; while (!tail.isEmpty() && !predicate.test(tail.head())) { init = init.prepend(tail.head()); tail = tail.tail(); } if (tail.isEmpty()) { return this; } else { return init.foldLeft(tail.tail(), List::prepend); } }
@Override default List<T> filter(Predicate<? super T> predicate) { Objects.requireNonNull(predicate, "predicate is null"); if (isEmpty()) { return this; } else { final List<T> filtered = foldLeft(empty(), (xs, x) -> predicate.test(x) ? xs.prepend(x) : xs); if (filtered.isEmpty()) { return empty(); } else if (filtered.length() == length()) { return this; } else { return filtered.reverse(); } } }
@Override default List<T> take(int n) { if (n <= 0) { return empty(); } if (n >= length()) { return this; } List<T> result = Nil.instance(); List<T> list = this; for (int i = 0; i < n; i++, list = list.tail()) { result = result.prepend(list.head()); } return result.reverse(); }
static <T> List<List<T>> apply(List<T> elements, int k) { if (k == 0) { return List.of(List.empty()); } else { return elements.zipWithIndex().flatMap( t -> apply(elements.drop(t._2 + 1), (k - 1)).map(c -> c.prepend(t._1)) ); } } }
static <T> Stream<T> apply(io.vavr.collection.List<T> front, io.vavr.collection.List<T> rear, Stream<T> remaining) { if (remaining.isEmpty()) { return remaining; } else if (front.isEmpty()) { return apply(rear.reverse(), io.vavr.collection.List.empty(), remaining); } else { return Stream.cons(front.head(), () -> apply(front.tail(), rear.prepend(remaining.head()), remaining.tail())); } } }
@Override default Tuple2<List<T>, List<T>> splitAt(int n) { if (isEmpty()) { return Tuple.of(empty(), empty()); } else { List<T> init = Nil.instance(); List<T> tail = this; while (n > 0 && !tail.isEmpty()) { init = init.prepend(tail.head()); tail = tail.tail(); n--; } return Tuple.of(init.reverse(), tail); } }
@Override default Tuple2<List<T>, List<T>> splitAtInclusive(Predicate<? super T> predicate) { if (isEmpty()) { return Tuple.of(empty(), empty()); } else { final Tuple2<List<T>, List<T>> t = SplitAt.splitByPredicateReversed(this, predicate); if (t._2.isEmpty() || t._2.tail().isEmpty()) { return Tuple.of(this, empty()); } else { return Tuple.of(t._1.prepend(t._2.head()).reverse(), t._2.tail()); } } }