@Override default ImmutableList<T> insertAt(int pos, T... values) { if(pos==0) return prependAll(values); if(pos>=size()) return appendAll(values); return unitIterable(IterableX.super.insertAt(pos,values)); }
@Override default boolean containsValue(T value) { return ImmutableList.super.containsValue(value); } static <R> LazySeq<R> narrow(LazySeq<? extends R> rs) {
default ImmutableList<T> replaceFirst(T currentElement, T newElement){ ImmutableList<T> preceding = emptyUnit(); ImmutableList<T> tail = this; while(!tail.isEmpty()){ ImmutableList<T> ref= preceding; ImmutableList<T> tailRef = tail; Tuple3<ImmutableList<T>, ImmutableList<T>, Boolean> t3 = tail.fold(c -> { if (Objects.equals(c.head(), currentElement)) return Tuple.tuple(ref, tailRef, true); return Tuple.tuple(ref.prepend(c.head()), c.tail(), false); }, nil -> Tuple.tuple(ref, tailRef, true)); preceding = t3._1(); tail = t3._2(); if(t3._3()) break; } ImmutableList<T> start = preceding; return tail.fold(cons->cons.tail().prepend(newElement).prependAll(start), nil->this); } default ImmutableList<T> removeFirst(Predicate<? super T> pred){
@Override default ImmutableList<T> dropRight(int num) { if(num>size()) return emptyUnit(); return unitStream(stream().dropRight(num)); }
@Override default BankersQueue<T> drop(long num) { if(num<=0) return this; if(num>=size()) return empty(); return this.foldBankersQueue(c -> { ImmutableList<T> newFront = c.front.drop(num); ImmutableList<T> newBack = c.back.dropRight((int) num - c.front.size()); if (newFront.size() > 0 || newBack.size() > 0) return new Cons<>(newFront, newBack); return empty(); }, nil -> nil); }
@Override default <R1, R> Seq<R> forEach2(Function<? super T, ? extends Iterable<R1>> iterable1, BiFunction<? super T, ? super R1, Boolean> filterFunction, BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) { return (Seq< R>) ImmutableList.super.forEach2(iterable1,filterFunction,yieldingFunction); } default Either<Integer,Seq<T>> set(int pos, T value) {
@Override default Seq<T> dropRight(int num) { return (Seq<T>) ImmutableList.super.dropRight(num); }
@Override default LazySeq<T> appendAll(T... values) { return (LazySeq<T>) ImmutableList.super.appendAll(values); }
@Override public T next() { return current.fold(c->{ current = c.tail(); return c.head(); },n->null); } };
public <R> NonEmptyList<R> flatMapNel(Function<? super T, ? extends NonEmptyList<R>> fn) { return fn.apply(head).appendAll(tail.flatMap(fn)); }