eu.bandm.tools.ops

Class Iterables

java.lang.Object

eu.bandm.tools.ops.Iterables

public abstract class Iterables
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Iterables.Cached<A>
static class	Iterables.FilterIterable<A>
static class	Iterables.FilterTest

Field Summary

Fields

Modifier and Type	Field and Description
static Operator	unfoldOperator

Method Summary

Modifier and Type	Method and Description
static <A,B> boolean	allZip(Relation<? super A,? super B> rel, Iterable<? extends A> left, Iterable<? extends B> right)
static <A,B> boolean	anyZip(Relation<? super A,? super B> rel, Iterable<? extends A> left, Iterable<? extends B> right)
static <A,B,C> Iterable<C>	asProduct(BiFunction<? super A,? super B,? extends C> fun, Iterable<? extends A> left, Iterable<? extends B> right)
static <A> Iterables.Cached<A>	cache(Iterable<A> things)
static <A,B> Iterable<B>	comprehend(Iterable<? extends A> gen, Function<? super A,? extends Iterable<? extends B>> map)
static <A,B> Iterable<B>	comprehend(Iterable<? extends A> gen, Predicate<? super A> filter, Function<? super A,? extends B> map)
static <A> Iterable<A>	concat(Iterable<? extends A> first, Iterable<? extends A> second)
static <A> Iterable<A>	cons(A first, Iterable<? extends A> rest)
static <A> Iterable<A>	drop(int offset, Iterable<A> things)
static <A> Iterable<A>	dropTake(int offset, int length, Iterable<A> things)
static <A> void	elementwise(Sink<? super A> sink, Iterable<A> things)
static <A> Iterable<A>	empty()
static Iterable<BigInteger>	factor(BigInteger n)
static <A> Iterable<A>	filter(Predicate<? super A> pred, Iterable<? extends A> things)
static <A,B> Iterable<A>	filterWithConstraint(Relation<? super A,? super B> rel, Iterable<A> things, Iterable<B> constraints)
static <A> Iterable<A>	flatten(Iterable<? extends Iterable<? extends A>> items)
static <D,S> S	fold(Consumer<? super D,S> consumer, S initialState, Iterable<? extends D> things)
static <A,M> M	fold(GenMonoid<? super A,M> monoid, Iterable<? extends A> things)
static <A,M> M	fold(GenSemigroup<? super A,M> semi, Iterable<? extends A> things)
static <D,S> S	fold(InitConsumer<? super D,S> consumer, Iterable<? extends D> things)
static <A> Function<Iterable<A>,Iterator<A>>	iterator()
static <A> Iterable<A>	loop(A init, Predicate<? super A> cond, Function<? super A,? extends A> iter)
static void	main(String[] args)
static <A,B,C> Map<A,C>	makeIndex(Function<? super B,? extends A> fun, GenSemigroup<? super B,C> sgrp, Iterable<? extends B> things)
static <A,B> Iterable<B>	map(Function<? super A,? extends B> fun, Iterable<? extends A> things)
static <A> Iterable<A>	merge(Comparator<? super A> order, boolean removeDuplicates, Iterable<? extends A> left, Iterable<? extends A> right)
static <A> Iterable<A>	next(Iterable<A> things)
static <A> Iterable<A>	nothing()
static <A> void	pairwise(PairSink<? super A,? super A> sink, Iterable<A> things)
static <A,B> void	parallel(PairSink<? super A,? super B> sink, Iterable<A> things, Iterable<B> more)
static Iterable<BigInteger>	primes()
static <A> Iterable<A>	singleton(A item)
static <A> Iterable<A>	take(int length, Iterable<A> things)
static <R,S> Function<InitProducer<? extends R,S>,Iterable<R>>	unfold()
static <R,S> Iterable<R>	unfold(InitProducer<? extends R,S> p)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

unfoldOperator

public static final Operator unfoldOperator

Method Detail

empty

public static <A> Iterable<A> empty()

map

public static <A,B> Iterable<B> map(Function<? super A,? extends B> fun,
                                    Iterable<? extends A> things)

unfold

public static <R,S> Iterable<R> unfold(InitProducer<? extends R,S> p)

unfold

public static <R,S> Function<InitProducer<? extends R,S>,Iterable<R>> unfold()

fold

public static <A,M> M fold(GenSemigroup<? super A,M> semi,
                           Iterable<? extends A> things)

fold

public static <A,M> M fold(GenMonoid<? super A,M> monoid,
                           Iterable<? extends A> things)

fold

public static <D,S> S fold(InitConsumer<? super D,S> consumer,
                           Iterable<? extends D> things)

fold

public static <D,S> S fold(Consumer<? super D,S> consumer,
                           S initialState,
                           Iterable<? extends D> things)

singleton

public static <A> Iterable<A> singleton(A item)

flatten

public static <A> Iterable<A> flatten(Iterable<? extends Iterable<? extends A>> items)

cons

public static <A> Iterable<A> cons(A first,
                                   Iterable<? extends A> rest)

concat

public static <A> Iterable<A> concat(Iterable<? extends A> first,
                                     Iterable<? extends A> second)

loop

public static <A> Iterable<A> loop(A init,
                                   Predicate<? super A> cond,
                                   Function<? super A,? extends A> iter)

filter

public static <A> Iterable<A> filter(Predicate<? super A> pred,
                                     Iterable<? extends A> things)

iterator

public static <A> Function<Iterable<A>,Iterator<A>> iterator()

comprehend

public static <A,B> Iterable<B> comprehend(Iterable<? extends A> gen,
                                           Predicate<? super A> filter,
                                           Function<? super A,? extends B> map)

comprehend

public static <A,B> Iterable<B> comprehend(Iterable<? extends A> gen,
                                           Function<? super A,? extends Iterable<? extends B>> map)

cache

public static <A> Iterables.Cached<A> cache(Iterable<A> things)

next

public static <A> Iterable<A> next(Iterable<A> things)

allZip

public static <A,B> boolean allZip(Relation<? super A,? super B> rel,
                                   Iterable<? extends A> left,
                                   Iterable<? extends B> right)

anyZip

public static <A,B> boolean anyZip(Relation<? super A,? super B> rel,
                                   Iterable<? extends A> left,
                                   Iterable<? extends B> right)

asProduct

public static <A,B,C> Iterable<C> asProduct(BiFunction<? super A,? super B,? extends C> fun,
                                            Iterable<? extends A> left,
                                            Iterable<? extends B> right)

makeIndex

public static <A,B,C> Map<A,C> makeIndex(Function<? super B,? extends A> fun,
                                         GenSemigroup<? super B,C> sgrp,
                                         Iterable<? extends B> things)

nothing

public static <A> Iterable<A> nothing()

primes

public static Iterable<BigInteger> primes()

factor

public static Iterable<BigInteger> factor(BigInteger n)

main

public static void main(String[] args)

merge

public static <A> Iterable<A> merge(Comparator<? super A> order,
                                    boolean removeDuplicates,
                                    Iterable<? extends A> left,
                                    Iterable<? extends A> right)

filterWithConstraint

public static <A,B> Iterable<A> filterWithConstraint(Relation<? super A,? super B> rel,
                                                     Iterable<A> things,
                                                     Iterable<B> constraints)

drop

public static <A> Iterable<A> drop(int offset,
                                   Iterable<A> things)

take

public static <A> Iterable<A> take(int length,
                                   Iterable<A> things)

dropTake

public static <A> Iterable<A> dropTake(int offset,
                                       int length,
                                       Iterable<A> things)

elementwise

public static <A> void elementwise(Sink<? super A> sink,
                                   Iterable<A> things)

pairwise

public static <A> void pairwise(PairSink<? super A,? super A> sink,
                                Iterable<A> things)

parallel

public static <A,B> void parallel(PairSink<? super A,? super B> sink,
                                  Iterable<A> things,
                                  Iterable<B> more)