@Override public <T> LazySeq<T> empty() { return LazySeq.empty(); }
private <R> ImmutableList<R> unitIterator(Iterator<R> it) { if(it.hasNext()){ return cons(it.next(), LazySeq.fromIterator(it)); } return LazySeq.empty(); }
default LazySeq<T> reverse() { return defer(()-> { LazySeq<T> res = empty(); for (T a : this) { res = res.prepend(a); } return res; }); } default Tuple2<LazySeq<T>,LazySeq<T>> duplicate(){
@Override public ImmutableList<T> take(long num) { if(num<=0){ return LazySeq.empty(); } return cons(head,tail.take(num-1)); }
private static <T> BankersQueue<T> check(Cons<T> check) { if(check.sizeBack<=check.sizeFront) return check; return new Cons((check.sizeFront + check.sizeBack), check.front.appendAll(check.back.reverse()), 0, LazySeq.empty()); }
static <T> LazySeq<T> fromStream(Stream<T> stream){ Iterator<T> t = stream.iterator(); return new Lazy<>(Eval.later(()->t.hasNext() ? cons(Eval.later(()->t.next()),head-> { head.get(); return ()->fromIterator(t); }) : empty())); } @SafeVarargs
static <T> LazySeq<T> fromIterator(Iterator<T> it){ return new Lazy<>(Eval.later(()->it.hasNext() ? cons(Eval.later(()->it.next()), head ->{ head.get(); return ()->fromIterator(it); } ) : empty())); } static <T> LazySeq<T> fromStream(Stream<T> stream){
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) {
@Test public void hashCodeTest(){ assertThat(empty.hashCode(),equalTo(LazySeq.empty().hashCode())); } @Test
@Test public void fromIterable() { assertThat(empty,equalTo(LazyString.fromIterable(LazySeq.empty()))); assertThat(str,equalTo(LazyString.fromIterable(helloWorld))); }
public Zipper<T> cycleNext() { return left.fold(cons->right.fold(c->next().orElse(this), nil->{ return of(LazySeq.empty(),cons.head(),cons.tail().append(point)); }),nil->this); } public Zipper<T> cyclePrevious() {
public Zipper<T> cyclePrevious() { return right.fold(cons->left.fold(c->previous().orElse(this), nil->{ ImmutableList.Some<T> reversed = cons.reverse(); return of(reversed.tail().reverse().prepend(point),reversed.head(), LazySeq.empty()); }),nil->this); } public <R> Option<Zipper<T>> previous(){
@Test public void applicativeLazySeq(){ Either<String,String> fail1 = Either.left("failed1"); Either<LazySeq<String>,String> result = fail1.combineToLazySeq(Either.<String,String>left("failed2"),(a, b)->a+b); assertThat(result.leftOrElse(LazySeq.empty()),equalTo(LazySeq.of("failed2","failed1"))); } @Test
@Test public void words() { assertThat(str.words().map(ls->ls.toString()),equalTo(LazySeq.of("hello", "world"))); assertThat(empty.words().map(ls->ls.toString()),equalTo(LazySeq.empty())); }
@Test public void position() throws Exception { assertThat(z.position(0).orElse(z2),equalTo(Zipper.of(LazySeq.empty(),1,LazySeq.of(2,3,5,10,20,30)))); assertThat(z.position(1).orElse(z2),equalTo(Zipper.of(LazySeq.of(1),2,LazySeq.of(3,5,10,20,30)))); }
@Test public void applicativeColleciton(){ Either<String,String> fail1 = Either.left("failed1"); Either<LazySeq<String>,String> result = fail1.lazySeq().combine(Either.left("failed2").lazySeq(), Semigroups.lazySeqConcat(),(a, b)->a+b); assertThat(result.leftOrElse(LazySeq.empty()),equalTo(LazySeq.of("failed2","failed1"))); } @Test