@Override public boolean hasNext() { return current.fold(c->true, n->false); }
@Override public boolean hasNext() { return current.fold(c->true, n->false); }
@Override public <R> R fold(BiFunction<? super T, ? super ImmutableList<T>, ? extends R> fn, Supplier<? extends R> alt) { return run().fold(fn,alt); }
@Override public <R> R fold(Function<? super Some<T>, ? extends R> fn1, Function<? super None<T>, ? extends R> fn2) { return run().fold(fn1,fn2); }
@Override public T next() { return current.fold(c->{ current = c.tail(); return c.head(); },n->null); } };
public Tuple2<T,BankersQueue<T>> dequeue() { return front.fold(cons->cons.fold((head, tail)->Tuple.tuple(head,tail())) ,nil->{throw new RuntimeException("Unreachable!");}); } public T head(){
public BankersQueue<T> tail() { if(size()==1) return empty(); if(sizeFront==0){ return BankersQueue.ofAll(back.fold(s->s.fold((h, t)->t), n->n)); } if(sizeFront==1){ return ofAll(back); } return new BankersQueue.Cons<>(sizeFront-1,front.fold(s->s.fold((h, t)->t), n->n),sizeBack,back); } public BankersQueue<T> replace(T currentElement, T newElement) {
@Override public NonEmptyList<T> replaceFirst(T currentElement, T newElement){ return ImmutableList.Some.super.replaceFirst(currentElement,newElement) .fold(cons->cons(cons.head(),cons.tail()),nil->this); }
public Option<Zipper<T>> deleteLeft() { return left.fold(c->right.fold(c2-> Option.some(of(c.dropRight(1),c.last(null),right)), n-> Option.some(of(c.dropRight(1),c.last(null),right))), n->right.fold(c-> Option.some(of(left,c.head(),c.tail())), n2-> Option.none())); } public Option<Zipper<T>> deleteRight() {
@Test public void when2(){ Integer res = of(1,2,3).fold((x,xs)->x,()->10); System.out.println(res); } @Test
@Test public void whenGreaterThan2NoOrd() { String res = of(5, 2, 3).fold((x, xs) -> xs.join(x > 2 ? "hello" : "world"), () -> "boo!"); MatcherAssert.assertThat(res, equalTo("2hello3")); }
@Test public void visit(){ String res= of(1,2,3).fold((x,xs)-> xs.join(x>2? "hello" : "world"), ()->"boo!"); MatcherAssert.assertThat(res,equalTo("2world3")); }
default Seq<T> seq(){ if(this instanceof Seq){ return (Seq<T>)this; } return fold(c->Seq.cons(c.head(),c.tail().seq()), nil->Seq.empty()); } default Option<NonEmptyList<T>> nonEmptyList(){
default Option<Zipper<T>> focusAt(int pos){ Tuple2<ImmutableList<T>, ImmutableList<T>> t2 = splitAt(pos); Option<T> value = t2._2().fold(c -> Option.some(c.head()), n -> Option.none()); return value.map(l-> { ImmutableList<T> right = t2._2().fold(c -> c.tail(), n -> null); return Zipper.of(t2._1(), l, right); }); }
@Test public void whenNilOrNotJoinWithFirstElementNoOrd(){ String res= of(1,2,3).fold((x,xs)-> xs.join(x>2? "hello" : "world"),()->"EMPTY"); MatcherAssert.assertThat(res,equalTo("2world3")); } @Test
default LazySeq<T> lazySeq(){ if(this instanceof LazySeq){ return (LazySeq<T>)this; } return fold(c->LazySeq.lazy(c.head(),()->c.tail().lazySeq()), nil->LazySeq.empty()); } default Seq<T> seq(){