default T getOrElse(int pos, T alt){ if(pos<0) return alt; T result = null; LazySeq<T> l = this; for(int i=0;i<pos;i++){ l = l.foldLazySeq(c->c.tail.get(), n->n); if(l instanceof Nil){ //short circuit return alt; } } return l.foldLazySeq(c->c.head.get(), n->alt); } default T getOrElseGet(int pos, Supplier<? extends T> alt){
default T getOrElseGet(int pos, Supplier<? extends T> alt){ if(pos<0) return alt.get(); T result = null; LazySeq<T> l = this; for(int i=0;i<pos;i++){ l = l.foldLazySeq(c->c.tail.get(), n->n); if(l instanceof Nil){ //short circuit return alt.get(); } } return l.foldLazySeq(c->c.head.get(), n->alt.get()); }
default LazySeq<T> tailOrElseGet(Supplier<? extends LazySeq<T>> tail){ return foldLazySeq(s->s.tail(), nil->tail.get()); } @Override
@Override public <R> R foldLazySeq(Function<? super Cons<T>, ? extends R> fn1, Function<? super Nil, ? extends R> fn2) { return ref.get().foldLazySeq(fn1,fn2); }
default LazySeq<T> tailOrElse(LazySeq<T> tail){ return foldLazySeq(s->s.tail(), nil->tail); } default LazySeq<T> tailOrElseGet(Supplier<? extends LazySeq<T>> tail){
@Override public T next() { return current.foldLazySeq(c->{ current = c.tail.get(); return c.head.get(); },n->null); } };
default T headOrElse(T head){ return foldLazySeq(s->s.head(), nil->head); } default T headOrElseGet(Supplier<? extends T> head){
default T headOrElseGet(Supplier<? extends T> head){ return foldLazySeq(s->s.head(), nil->head.get()); } default LazySeq<T> tailOrElse(LazySeq<T> tail){
default LazySeq<T> drop(final long num) { return defer(()-> { LazySeq<T> current = this; long pos = num; while (pos-- > 0 && !current.isEmpty()) { current = current.foldLazySeq(c -> c.tail.get(), nil -> nil); } return current; }); } default LazySeq<T> reverse() {
default LazySeq<T> appendAll(Iterable<? extends T> it) { return defer(()->{ LazySeq<T> append = narrow(fromIterable(it)); return this.foldLazySeq(cons->{ return append.foldLazySeq(c2->{ return cons(cons.head,()->cons.tail.get().appendAll(append)); },n2->this); },nil->append); }); } default <R> R foldLeft(R zero, BiFunction<R, ? super T, R> f){
default LazySeq<T> dropWhile(Predicate<? super T> p) { return defer(()-> { LazySeq<T> current = this; boolean[] found = {false}; while (!found[0] && !current.isEmpty()) { LazySeq<T> active = current; current = current.foldLazySeq(c -> { if (!p.test(c.head.get())) { found[0] = true; return active; } return c.tail.get(); }, empty -> empty); } return current; }); } default LazySeq<T> drop(final long num) {
private <R> Tuple2<Boolean,R> lazyFoldRightImpl(R zero, BiFunction<? super T,Supplier<R>, ? extends R> f){ boolean[] called= {false}; R x = f.apply(head.get(), () -> { called[0] = true; LazySeq<T> ls = tail.get(); return ls.foldLazySeq(s -> { Tuple2<Boolean, R> t2 = s.lazyFoldRightImpl(zero, f); if(t2._1()) called[0]=true; return t2._2(); }, n -> zero); }); return Tuple.tuple(called[0],x); }
default LazySeq<T> takeWhile(Predicate<? super T> p) { return new Lazy<T>(Eval.later(()->foldLazySeq(c->{ if(p.test(c.head())){ return cons(c.head,()->c.tail.get().takeWhile(p)); }else{ return empty(); } },n->this))); } default LazySeq<T> dropWhile(Predicate<? super T> p) {
default LazySeq<LazySeq<T>> split(Predicate<? super T> test) { return defer(()->{ LazySeq<T> next = dropWhile(test); Tuple2<LazySeq<T>, LazySeq<T>> split = next.splitBy(test).bimap(ImmutableList::lazySeq,ImmutableList::lazySeq); return next.foldLazySeq(c->cons(split._1(),()->split._2().split(test)), n->n); }); } default LazySeq<T> take(final long n) {
public <R> R lazyFoldRight(R zero, BiFunction<? super T,Supplier<R>, ? extends R> f){ long inc = 500; LazySeq<T> host = this; long count = inc; LazySeq<T> next = host.take(count); if(next.isEmpty()) return zero; Tuple2<Boolean,R> value = Tuple.tuple(true,zero); while(!next.isEmpty() && value._1()) { Cons<T> cons = next.foldLazySeq(c -> c, n -> null); value = cons.lazyFoldRightImpl(value._2(), f); next = host.drop(count).take(inc); count = count + inc; } return value._2(); }
@Override public T next() { return current.foldLazySeq(c->{ current = c.tail.get(); return c.head.get(); },n->null); } };
default T headOrElse(T head){ return foldLazySeq(s->s.head(), nil->head); } default T headOrElseGet(Supplier<? extends T> head){
default LazySeq<T> appendAll(Iterable<? extends T> it) { return defer(()->{ LazySeq<T> append = narrow(fromIterable(it)); return this.foldLazySeq(cons->{ return append.foldLazySeq(c2->{ return cons(cons.head,()->cons.tail.get().appendAll(append)); },n2->this); },nil->append); }); } default <R> R foldLeft(R zero, BiFunction<R, ? super T, R> f){
default LazySeq<T> takeWhile(Predicate<? super T> p) { return new Lazy<T>(Eval.later(()->foldLazySeq(c->{ if(p.test(c.head())){ return cons(c.head,()->c.tail.get().takeWhile(p)); }else{ return empty(); } },n->this))); } default LazySeq<T> dropWhile(Predicate<? super T> p) {
default LazySeq<LazySeq<T>> split(Predicate<? super T> test) { return defer(()->{ LazySeq<T> next = dropWhile(test); Tuple2<LazySeq<T>, LazySeq<T>> split = next.splitBy(test).bimap(ImmutableList::lazySeq,ImmutableList::lazySeq); return next.foldLazySeq(c->cons(split._1(),()->split._2().split(test)), n->n); }); } default LazySeq<T> take(final long n) {