@Override public DifferenceList<T> emptyUnit() { return empty(); }
@Override public <R> DifferenceList<R> concatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) { return flatMap(mapper.andThen(DifferenceList::fromIterable)); }
@Override public DifferenceList<T> drop(long num) { return fromStream(stream().drop(num)); }
private static <T> ImmutableList<T> resolve(ImmutableList<T> immutableList){ if(immutableList instanceof DifferenceList){ return ((DifferenceList<T>) immutableList).run(); } return immutableList; } public ImmutableList<T> run(){
@Override public <R> DifferenceList<R> unitStream(Stream<R> stream) { return fromStream(stream); }
@Override public DifferenceList<T> filter(Predicate<? super T> fn) { return new DifferenceList<>(l-> Trampoline.done(run().filter(fn))); }
public static DifferenceList<Integer> range(final int start, final int end) { return of(LazySeq.range(start,end)); } public static DifferenceList<Integer> range(final int start, final int step, final int end) {
@Override public <R> DifferenceList<R> mergeMap(Function<? super T, ? extends Publisher<? extends R>> fn) { return fromIterable(stream().mergeMap(fn)); }
@Test public void memoize(){ count =0; DifferenceList<Integer> list = DifferenceList.of(LazySeq.range(1,10)).map(i->count++); System.out.println(list.size()); assertThat(count,equalTo(9)); System.out.println(list.size()); assertThat(count,equalTo(18)); list = list.memoize(); System.out.println(list.size()); assertThat(count,equalTo(27)); System.out.println(list.size()); assertThat(count,equalTo(27)); } @Test
@Override public DifferenceList<T> appendAll(Iterable<? extends T> value) { DifferenceList<T> res = this; for(T next : value){ res = res.append(next); } return res; }
public static <T> DifferenceList<T> empty(){ return new DifferenceList<>(l-> Trampoline.done(l)); } public static <U, T> DifferenceList<T> unfold(final U seed, final Function<? super U, Option<Tuple2<T, U>>> unfolder) {
@Override public boolean equals(Object obj) { if(obj==null) return false; if (obj == this) return true; if(obj instanceof PersistentIndexed) { return equalToIteration((Iterable)obj); } return false; }
@Override public <R> DifferenceList<R> unitIterable(Iterable<R> it) { return fromIterable(it); }
@Override public ImmutableList<T> tailOrElse(ImmutableList<T> tail) { return fold(s->this,__->tail); }