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) {
public LazySeq<LazySeq<T>> levels() { ReactiveSeq<LazySeq<T>> res = ReactiveSeq.iterate(LazySeq.of(this), sf -> sf.flatMap(a -> a.subForest())) .takeWhile(l -> !l.isEmpty()) .map(xs -> xs.map(x -> x.head)); return LazySeq.fromStream(res); }
@Test public void testLazy(){ of(1,2,3,4).map(i->count++); assertThat(count,equalTo(0)); count =0; of(1,2,3,4).flatMap(i->{ System.out.println("here!"); return LazySeq.of(count++); }); assertThat(count,equalTo(0)); count =0; of(1,2,3,4).concatMap(i->LazySeq.of(count++)); assertThat(count,equalTo(0)); count =0; of(1,2,3,4).filter(i->{ count++; return i>0; }); assertThat(count,equalTo(0)); count =0; of(1,2,3,4).zip(of(1,2,3,4),(a,b)->{ count++; return a; }); assertThat(count,equalTo(0)); }
static <T,R> LazySeq<R> tailRec(T initial, Function<? super T, ? extends LazySeq<? extends Either<T, R>>> fn) { LazySeq<Either<T, R>> next = LazySeq.of(Either.left(initial)); boolean newValue[] = {true}; for(;;){ next = next.flatMap(e -> e.fold(s -> { newValue[0]=true; return fromStream(fn.apply(s).stream()); }, p -> { newValue[0]=false; return LazySeq.of(e); })); if(!newValue[0]) break; } ReactiveSeq<R> x = Either.sequenceRight(next.stream()).orElse(ReactiveSeq.empty()); return LazySeq.fromIterator(x.iterator()); } static <T> LazySeq<T> fill(T t){
@Override public V getOrElseGet(int hash, K key, Supplier<? extends V> alt) { return (hash == 0) ? bucket.filter(t2 -> t2._1().equals(key)).map(t->t._2()).getOrElseGet(0,alt) : alt.get(); }
@Override public Node<K, V> minus(int hash, K key) { if (hash != 0) return this; LazySeq<Tuple2<K, V>> newBucket = bucket.filter(t2 -> !t2._1().equals(key)); //@TODO safety return newBucket.fold(c->c.size()>1? new CollisionNode<K,V>(newBucket) : new SingleNode<>(newBucket.get(0).orElse(null)), nil-> HashedPatriciaTrie.empty()); }
@Override public <C2, T, R> Higher<C2, Higher<lazySeq, R>> traverseA(Applicative<C2> ap, Function<? super T, ? extends Higher<C2, R>> fn, Higher<lazySeq, T> ds) { LazySeq<T> v = narrowK(ds); return v.<Higher<C2, Higher<lazySeq,R>>>lazyFoldRight(ap.unit(LazySeq.<R>empty()), (b, a) -> ap.zip(fn.apply(b), a.get(), (sn, vec) -> narrowK(vec).plus(sn))); }
@Test public void laziness(){ boolean empty = LazySeq.generate(()->1) .filter(i -> false) .take(0) .isEmpty(); System.out.println("Empty ? " + empty); /** assertTrue(LazySeq.generate(()->1).filter(i -> false).take(0).isEmpty()); assertTrue(LazySeq.generate(()->1).flatMap(i -> LazySeq.empty()).take(0).isEmpty()); **/ }
@Override public <R> ImmutableList<R> flatMap(Function<? super Character, ? extends ImmutableList<? extends R>> fn) { return string.flatMap(fn); }
default <T> Higher<CRE,T> reverse(Higher<CRE, T> ds){ Tuple2<LazySeq<T>, Higher<CRE, T>> t2 = mapAccumL((t, h)-> tuple(t.plus(h),h),ds, LazySeq.empty()); return runTraverseS(t -> State.<LazySeq<T>>get() .forEach2(e -> State.put(e.tailOrElse(LazySeq.empty())), (a, b) -> a.headOrElse(null)) , t2._2(), t2._1())._2(); } default <T, R> R foldMap(Monoid<R> mb, final Function<? super T,? extends R> fn, Higher<CRE, T> ds) {
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