Skip navigation links
A B C D E F G H I J L M N O P Q R S T U V W X Y Z 

A

addToSet(int, int, int, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
aggregate(AnyM<T>) - Method in interface com.aol.cyclops.monad.AnyM
Aggregate the contents of this Monad and the supplied Monad
ALL_SPEC - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
ALL_SPEC_INT - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
allMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous All Match operation
allMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
True if predicate matches all elements when Monad converted to a Stream
allMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
True if predicate matches all elements when Monad converted to a Stream
AnyM<T> - Interface in com.aol.cyclops.monad
Wrapper for Any Monad type
anyM() - Method in interface com.aol.cyclops.sequence.SequenceM
 
anyM() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
anyMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous Any Match operation
anyMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
True if a single element matches when Monad converted to a Stream
anyMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
True if a single element matches when Monad converted to a Stream
AnyMFactory - Interface in com.aol.cyclops.monad
 
AnyMFactory.MetaFactory - Class in com.aol.cyclops.monad
 
AnyMFunctions - Interface in com.aol.cyclops.monad
 
anyMonads() - Method in interface com.aol.cyclops.monad.AnyMFactory
 
append(T...) - Method in interface com.aol.cyclops.sequence.SequenceM
Append values to the end of this SequenceM
append(T...) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Append values to the end of this Streamable
appendAll(Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a new Streamablw with all elements in this Streamable followed by the elements in the provided Streamable
appendStream(Stream<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Append Stream to this SequenceM
appendStreamable(Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Append Stream to this Streamable
applyM(AnyM<Function<? super T, ? extends R>>) - Method in interface com.aol.cyclops.monad.AnyM
Apply function/s inside supplied Monad to data in current Monad e.g.
ApplyM<T> - Interface in com.aol.cyclops.monad
 
applyMCompletableFuture(CompletableFuture<Function<? super T, ? extends R>>) - Method in interface com.aol.cyclops.monad.ApplyM
Apply function/s inside supplied Monad to data in current Monad
applyMIterable(Iterable<Function<? super T, ? extends R>>) - Method in interface com.aol.cyclops.monad.ApplyM
Apply function/s inside supplied Monad to data in current Monad e.g.
applyMOptional(Optional<Function<? super T, ? extends R>>) - Method in interface com.aol.cyclops.monad.ApplyM
Apply function/s inside supplied Monad to data in current Monad with Optionals
applyMStream(Stream<Function<? super T, ? extends R>>) - Method in interface com.aol.cyclops.monad.ApplyM
Apply function/s inside supplied Monad to data in current Monad e.g.
AsDecomposable - Class in com.aol.cyclops.objects
 
AsDecomposable() - Constructor for class com.aol.cyclops.objects.AsDecomposable
 
asDecomposable(Object) - Static method in class com.aol.cyclops.objects.AsDecomposable
Coerce / wrap an Object as a Decomposable instance This adds an unapply method that returns an interable over the supplied objects fields.
AsDecomposable.CoercedDecomposable - Class in com.aol.cyclops.objects
 
asSequence() - Method in interface com.aol.cyclops.monad.AnyM
Wrap this Monad's contents as a Sequence without disaggreating it.
AsStreamable - Class in com.aol.cyclops.sequence.streamable
 
AsStreamable() - Constructor for class com.aol.cyclops.sequence.streamable.AsStreamable
 
averageDouble(ToDoubleFunction<T>) - Method in interface com.aol.cyclops.sequence.future.DoubleOperators
Perform an asynchronous average operation
averageInt(ToIntFunction<T>) - Method in interface com.aol.cyclops.sequence.future.IntOperators
Perform an asynchronous average operation
averageLong(ToLongFunction<T>) - Method in interface com.aol.cyclops.sequence.future.LongOperators
Perform an asynchronous average operation

B

batchBySize(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements in a Stream by size into Lists
batchBySize(int, Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements in a Stream by size into a collection created by the supplied factory
batchBySize(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements in a Stream by size into Lists
batchBySize(int, Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements in a Stream by size into a collection created by the supplied factory
batchBySizeAndTime(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements by size into a List
batchBySizeAndTime(int, long, TimeUnit, Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements by size into a collection created by the supplied factory
batchBySizeAndTime(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements by size into a List
batchBySizeAndTime(int, long, TimeUnit, Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements by size into a collection created by the supplied factory
batchByTime(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements in a Stream by time period
batchByTime(long, TimeUnit, Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Batch elements by time into a collection created by the supplied factory
batchByTime(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements in a Stream by time period
batchByTime(long, TimeUnit, Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Batch elements by time into a collection created by the supplied factory
batchUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a SequenceM batched by List, where each batch is populated until the predicate holds
batchUntil(Predicate<? super T>, Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds
batchUntil(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Streamable batched by List, where each batch is populated until the predicate holds
batchUntil(Predicate<T>, Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Streamable batched by a Collection, where each batch is populated until the predicate holds
batchWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a SequenceM batched by List, where each batch is populated while the predicate holds
batchWhile(Predicate<? super T>, Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
batchWhile(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Streamable batched by List, where each batch is populated while the predicate holds
batchWhile(Predicate<T>, Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Streamable batched by a Collection, where each batch is populated while the predicate holds
bind(Function<? super T, ?>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a looser typed flatMap / bind operation The return type can be another type other than the host type Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.
block() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
Block until the currently active reactive task completes
buildExpression(String) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

C

cancel() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
 
cast(Class<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
cast(Class<U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
characteristics() - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
characteristics() - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
characteristics() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
characteristics() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
checkNext(int, String, int, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
clone() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Deprecated.
CoercedDecomposable() - Constructor for class com.aol.cyclops.objects.AsDecomposable.CoercedDecomposable
 
collect(Collector<? super T, A, R>) - Method in interface com.aol.cyclops.monad.AnyM
Collect the contents of the monad wrapped by this AnyM into supplied collector
collect(Collector<? super T, A, R>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream collection
collect(Supplier<R>, BiConsumer<R, ? super T>, BiConsumer<R, R>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream collection
collect(Supplier<R>, BiConsumer<R, ? super T>, BiConsumer<R, R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
collect(Collector<? super T, A, R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
collectIterable(Iterable<Collector>) - Method in interface com.aol.cyclops.sequence.SequenceM
Deprecated.
collectIterable(Iterable<Collector>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Apply multiple Collectors, simultaneously to a Stream
collectStream(Stream<Collector>) - Method in interface com.aol.cyclops.sequence.SequenceM
Deprecated.
collectStream(Stream<Collector>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Apply multiple collectors Simulataneously to this Monad
com.aol.cyclops.monad - package com.aol.cyclops.monad
 
com.aol.cyclops.objects - package com.aol.cyclops.objects
 
com.aol.cyclops.scheduling.util.cron - package com.aol.cyclops.scheduling.util.cron
 
com.aol.cyclops.sequence - package com.aol.cyclops.sequence
 
com.aol.cyclops.sequence.future - package com.aol.cyclops.sequence.future
 
com.aol.cyclops.sequence.reactivestreams - package com.aol.cyclops.sequence.reactivestreams
 
com.aol.cyclops.sequence.spliterators - package com.aol.cyclops.sequence.spliterators
 
com.aol.cyclops.sequence.streamable - package com.aol.cyclops.sequence.streamable
 
combinations(int) - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of(1,2,3).combinations(2) //SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
combinations() - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of(1,2,3).combinations() //SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3] ,SequenceM[1,2,3]]
combinations(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3).combinations(2) //Streamable[Streamable[1,2],Streamable[1,3],Streamable[2,3]]
combinations() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3).combinations() //Streamable[Streamable[],Streamable[1],Streamable[2],Streamable[3],Streamable[1,2],Streamable[1,3],Streamable[2,3] ,Streamable[1,2,3]]
combiner() - Method in interface com.aol.cyclops.sequence.Monoid
 
concat(Stream<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
concat(T) - Method in interface com.aol.cyclops.sequence.SequenceM
 
concat(T...) - Method in interface com.aol.cyclops.sequence.SequenceM
 
concat(Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
concat(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
concat(T...) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
connect() - Method in interface com.aol.cyclops.sequence.HotStream
 
connect(Queue<T>) - Method in interface com.aol.cyclops.sequence.HotStream
 
connectTo(Queue<T>, Function<SequenceM<T>, R>) - Method in interface com.aol.cyclops.sequence.HotStream
 
contains(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
True if a streamable contains element t
copy() - Method in interface com.aol.cyclops.sequence.spliterators.ReversableSpliterator
 
copy() - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
copy() - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
copy() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
copy() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
count() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream count
count() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
CronExpression - Class in com.aol.cyclops.scheduling.util.cron
Provides a parser and evaluator for unix-like cron expressions.
CronExpression(String) - Constructor for class com.aol.cyclops.scheduling.util.cron.CronExpression
Constructs a new CronExpression based on the specified parameter.
CronExpression(CronExpression) - Constructor for class com.aol.cyclops.scheduling.util.cron.CronExpression
Constructs a new CronExpression as a copy of an existing instance.
crossJoin(Stream<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
crossJoin(Streamable<U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
cycle(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Convert to a Stream with the values repeated specified times
cycle() - Method in interface com.aol.cyclops.sequence.SequenceM
Convert to a Stream with the values infinitely cycled
cycle(Monoid<T>, int) - Method in interface com.aol.cyclops.sequence.SequenceM
Convert to a Stream with the result of a reduction operation repeated specified times
cycle(Class<R>, int) - Method in interface com.aol.cyclops.sequence.SequenceM
Deprecated.
cycle(int, Streamable<U>) - Static method in class com.aol.cyclops.sequence.SeqUtils
Create a Stream that finitely cycles the provided Streamable, provided number of times
cycle(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Convert to a Stream with the values repeated specified times
cycle() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Convert to a Stream with the values infinitely cycled
cycle(Monoid<T>, int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Convert to a Stream with the result of a reduction operation repeated specified times
cycle(Class<R>, int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type
cycleUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Repeat in a Stream until specified predicate holds
cycleUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Repeat in a Stream until specified predicate holds
cycleWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Repeat in a Stream while specified predicate holds
cycleWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Repeat in a Stream while specified predicate holds
CyclopsSubscriber<T> - Interface in com.aol.cyclops.sequence.reactivestreams
 

D

DAY_OF_MONTH - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
DAY_OF_WEEK - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
dayMap - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
daysOfMonth - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
daysOfWeek - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
debounce(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Allow one element through per time period, drop all other elements in that time period
debounce(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Allow one element through per time period, drop all other elements in that time period
Decomposable - Interface in com.aol.cyclops.objects
trait / interface for Value Objects / Case Classes / Algebraic Data Types unapply uses Reflection by default, but clients can override it if neccessary
deleteBetween(int, int) - Method in interface com.aol.cyclops.sequence.SequenceM
Delete elements between given indexes in a Stream
deleteBetween(int, int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Delete elements between given indexes in a Stream
distinct() - Method in interface com.aol.cyclops.sequence.SequenceM
 
distinct(Function<? super T, ? extends U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
distinct() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
distinct(Function<? super T, ? extends U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
DoubleOperators<T> - Interface in com.aol.cyclops.sequence.future
 
duplicate() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
duplicateSequence() - Method in interface com.aol.cyclops.sequence.SequenceM
Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.

E

elapsed() - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);
elapsed() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);
elementAt(long) - Method in interface com.aol.cyclops.sequence.SequenceM
Return the elementAt index or Optional.empty
elementAt(long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Return the elementAt index or Optional.empty
empty() - Method in interface com.aol.cyclops.monad.AnyM
Construct an AnyM wrapping an empty instance of the wrapped type e.g.
empty() - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
 
endsWith(Iterable<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
assertTrue(SequenceM.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
endsWith(Stream<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
assertTrue(SequenceM.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));
endsWith(Iterable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertTrue(Streamable.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
endsWith(Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertTrue(Streamable.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));
estimateSize() - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
estimateSize() - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
estimateSize() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
estimateSize() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
expressionParsed - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

F

filter(Predicate<? super T>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a filter operation on the wrapped monad instance e.g.
filter(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
filter(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
findAny() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous findAny operation
findAny() - Method in interface com.aol.cyclops.sequence.SequenceM
 
findAny() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
findFirst() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous findAny operation
findFirst() - Method in interface com.aol.cyclops.sequence.SequenceM
 
findFirst() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
findNextWhiteSpace(int, String) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
firstValue() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous findAny operation
firstValue() - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));
firstValue() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));
fixedDelay(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
emit elements after a fixed delay
fixedDelay(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
emit elements after a fixed delay
flatMap(Function<? super T, AnyM<? extends R>>) - Method in interface com.aol.cyclops.monad.AnyM
flatMap operation AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584 In particular left-identity becomes Left identity: unit(a).flatMap(f) ≡ select(f.apply(a)) Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value, only the first value is accepted.
flatMap(Function<? super T, ? extends Stream<? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
flatMap operation
flatMap(Function<? super T, Streamable<? extends R>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
flatMapAnyM(Function<? super T, AnyM<? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Allows flatMap return type to be any Monad type
flatMapAnyM(Function<? super T, AnyM<? extends R>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Allows flatMap return type to be any Monad type
flatMapBufferedReader(Function<? super T, BufferedReader>) - Method in interface com.aol.cyclops.monad.FlatMapM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
flatMapBufferedReader(Function<? super T, BufferedReader>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
flatMapBufferedReader(Function<? super T, BufferedReader>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
flatMapCharSequence(Function<? super T, CharSequence>) - Method in interface com.aol.cyclops.monad.FlatMapM
Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
flatMapCharSequence(Function<? super T, CharSequence>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
flatMapCharSequence(Function<? super T, CharSequence>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
flatMapCollection(Function<? super T, Collection<? extends R>>) - Method in interface com.aol.cyclops.monad.FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Stream.
flatMapCollection(Function<? super T, Collection<? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
FlatMap where the result is a Collection, flattens the resultant collections into the host SequenceM
flatMapCollection(Function<? super T, Collection<? extends R>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
FlatMap where the result is a Collection, flattens the resultant collections into the host Streamable
flatMapCompletableFuture(Function<? super T, CompletableFuture<? extends R>>) - Method in interface com.aol.cyclops.monad.FlatMapM
 
flatMapCompletableFuture(Function<? super T, CompletableFuture<? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)
flatMapCompletableFuture(Function<? super T, CompletableFuture<? extends R>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)
flatMapFile(Function<? super T, File>) - Method in interface com.aol.cyclops.monad.FlatMapM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
flatMapFile(Function<? super T, File>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
flatMapFile(Function<? super T, File>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
FlatMapM<T> - Interface in com.aol.cyclops.monad
 
flatMapOptional(Function<? super T, Optional<? extends R>>) - Method in interface com.aol.cyclops.monad.FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Optional
flatMapOptional(Function<? super T, Optional<? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
flatMap to optional - will result in null values being removed
flatMapOptional(Function<? super T, Optional<? extends R>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
flatMap to optional - will result in null values being removed
flatMapSequenceM(Function<? super T, SequenceM<? extends R>>) - Method in interface com.aol.cyclops.monad.FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Stream.
flatMapStream(Function<? super T, BaseStream<? extends R, ?>>) - Method in interface com.aol.cyclops.monad.FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Stream.
flatMapStream(Function<? super T, BaseStream<? extends R, ?>>) - Method in interface com.aol.cyclops.sequence.SequenceM
flatMap operation
flatMapStream(Function<? super T, BaseStream<? extends R, ?>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
flatMap operation
flatMapStreamable(Function<? super T, Streamable<R>>) - Method in interface com.aol.cyclops.monad.FlatMapM
Convenience method to allow method reference support, when flatMap return type is a Stream.
flatMapURL(Function<? super T, URL>) - Method in interface com.aol.cyclops.monad.FlatMapM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
flatMapURL(Function<? super T, URL>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
flatMapURL(Function<? super T, URL>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
flatten() - Method in interface com.aol.cyclops.monad.AnyM
join / flatten one level of a nested hierarchy
flatten() - Method in interface com.aol.cyclops.sequence.SequenceM
join / flatten one level of a nested hierarchy
flatten() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
join / flatten one level of a nested hierarchy
foldLeft(U, BiFunction<U, ? super T, U>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous foldLeft operation
foldLeft(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of("a","b","c").foldLeft(Reducers.toString("")); // "abc"
foldLeft(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
foldLeft : immutable reduction from left to right
foldLeft(U, BiFunction<U, ? super T, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Fold a Streamable Left
foldLeft(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of("a","b","c").foldLeft(Reducers.toString("")); // "abc"
foldLeft(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
foldLeft : immutable reduction from left to right
foldLeftMapToType(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
foldLeftMapToType(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
foldRight(U, BiFunction<? super T, U, U>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous foldRight operation
foldRight(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of("a","b","c").foldRight(Reducers.toString("")); // "cab"
foldRight(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Immutable reduction from right to left
foldRight(U, BiFunction<? super T, U, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Fold a Streamable fromt the right
foldRight(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of("a","b","c").foldRight(Reducers.toString("")); // "cab"
foldRight(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Immutable reduction from right to left
foldRightMapToType(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
foldRightMapToType(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
forEach(Consumer<T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
forEach2(Function<? super T, ? extends AnyM<R1>>, Function<? super T, Function<? super R1, ? extends R>>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)
forEach2(Function<? super T, ? extends AnyM<R1>>, Function<? super T, Function<? super R1, Boolean>>, Function<? super T, Function<? super R1, ? extends R>>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling etc to be injected, for example)
forEach2(Function<? super T, ? extends BaseStream<R1, ?>>, Function<? super T, Function<? super R1, ? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a two level nested internal iteration over this Stream and the supplied stream
forEach2(Function<? super T, ? extends BaseStream<R1, ?>>, Function<? super T, Function<? super R1, Boolean>>, Function<? super T, Function<? super R1, ? extends R>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a two level nested internal iteration over this Stream and the supplied stream
forEach3(Function<? super T, ? extends AnyM<R1>>, Function<? super T, Function<? super R1, ? extends AnyM<R2>>>, Function<? super T, Function<? super R1, Function<? super R2, Boolean>>>, Function<? super T, Function<? super R1, Function<? super R2, ? extends R>>>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a three level nested internal iteration over this Stream and the supplied streams
forEach3(Function<? super T, ? extends AnyM<R1>>, Function<? super T, Function<? super R1, ? extends AnyM<R2>>>, Function<? super T, Function<? super R1, Function<? super R2, ? extends R>>>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a three level nested internal iteration over this AnyM and the supplied monads
forEach3(Function<? super T, ? extends BaseStream<R1, ?>>, Function<? super T, Function<? super R1, ? extends BaseStream<R2, ?>>>, Function<? super T, Function<? super R1, Function<? super R2, ? extends R>>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a three level nested internal iteration over this Stream and the supplied streams
forEach3(Function<? super T, ? extends BaseStream<R1, ?>>, Function<? super T, Function<? super R1, ? extends BaseStream<R2, ?>>>, Function<? super T, Function<? super R1, Function<? super R2, Boolean>>>, Function<? super T, Function<? super R1, Function<? super R2, ? extends R>>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Perform a three level nested internal iteration over this Stream and the supplied streams
forEachEvent(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
forEachEvent(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
forEachOrdered(Consumer<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
forEachWithError(Consumer<? super T>, Consumer<? super Throwable>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
forEachWithError(Consumer<? super T>, Consumer<? super Throwable>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
forEachX(long, Consumer<? super T>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations
Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
forEachX(long, Consumer<? super T>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
forEachXEvents(long, Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
forEachXEvents(long, Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
forEachXWithError(long, Consumer<? super T>, Consumer<? super Throwable>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
forEachXWithError(long, Consumer<? super T>, Consumer<? super Throwable>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
fromArray(T...) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM wrapping a Stream of the supplied data
fromCollection(Collection<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps a Collection
fromCompletableFuture(CompletableFuture<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps a CompletableFuture
fromDoubleStream(DoubleStream) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an DoubleStream
fromDoubleStream(DoubleStream) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from a Stream
fromDoubleStream(DoubleStream) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Sequence from a Stream
fromFile(File) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an textual Stream from a file
fromIntStream(IntStream) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an IntStream
fromIntStream(IntStream) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from a Stream
fromIntStream(IntStream) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Sequence from a Stream
fromIterable(Iterable<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an Iterable
fromIterable(Iterable<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from an Iterable
fromIterable(Iterable<T>) - Static method in class com.aol.cyclops.sequence.streamable.AsStreamable
 
fromIterable(Iterable<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
(Lazily) Construct a Streamable from an Iterable.
fromIterator(Iterator<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from an Iterator
fromList(List<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM from a List This AnyM will convert the List to a Stream under the covers, but will rematerialize the Stream as List if wrap() is called
fromList(List<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from a List (prefer this method if the source is a list, as it allows more efficient Stream reversal).
fromList(List<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
 
fromLongStream(LongStream) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an LongStream
fromLongStream(LongStream) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from a Stream
fromLongStream(LongStream) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Sequence from a Stream
fromObject(Object) - Static method in class com.aol.cyclops.sequence.streamable.AsStreamable
 
fromOptional(Optional<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an Optional
fromOptionalDouble(OptionalDouble) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an OptionalDouble
fromOptionalInt(OptionalInt) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an OptionalInt
fromOptionalLong(OptionalLong) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an OptionalLong
fromRange(int, int) - Static method in interface com.aol.cyclops.monad.AnyM
Construct an AnyM instance that wraps a range from start (inclusive) to end (exclusive) provided The AnyM will contain a SequenceM over the spefied range
fromRangeLong(long, long) - Static method in interface com.aol.cyclops.monad.AnyM
Construct an AnyM instance that wraps a range from start (inclusive) to end (exclusive) provided The AnyM will contain a SequenceM over the spefied range
fromSet(Set<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM from a Set This AnyM will convert the Set to a Stream under the covers, but will rematerialize the Stream as Set if wrap() is called
fromStream(Stream<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps a Stream
fromStream(Stream<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Sequence from a Stream
fromStream(Stream<T>) - Static method in class com.aol.cyclops.sequence.streamable.AsStreamable
 
fromStream(Stream<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
(Lazily) Construct a Streamable from a Stream.
fromStreamable(ToStream<T>) - Static method in interface com.aol.cyclops.monad.AnyM
Wrap a Streamable inside an AnyM
fromURL(URL) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM instance that wraps an textual Stream from a URL
FutureOperations<T> - Interface in com.aol.cyclops.sequence.future
 
futureOperations(Executor) - Method in interface com.aol.cyclops.sequence.SequenceM
Access asynchronous terminal operations (each returns a Future)
futureOperations(Executor) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Access asynchronous terminal operations (each returns a Future)

G

generate(Supplier<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
 
generate(Supplier<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
 
get(long) - Method in interface com.aol.cyclops.sequence.SequenceM
Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
get(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Gets the element at index (it must be present)
get(long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
getCronExpression() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getDayOfWeekNumber(String) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getExpressionSetSummary(Set<Integer>) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getExpressionSetSummary(ArrayList<Integer>) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getExpressionSummary() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getFinalFireTime() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
NOT YET IMPLEMENTED: Returns the final time that the CronExpression will match.
getLastDayOfMonth(int, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getMonthNumber(String) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getNextInvalidTimeAfter(Date) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Returns the next date/time after the given date/time which does not satisfy the expression
getNextValidTimeAfter(Date) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Returns the next date/time after the given date/time which satisfies the cron expression.
getNumericValue(String, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getStreamable() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
getTimeAfter(Date) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getTimeBefore(Date) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
NOT YET IMPLEMENTED: Returns the time before the given time that the CronExpression matches.
getTimeZone() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Returns the time zone for which this CronExpression will be resolved.
getValue(int, String, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
getValue() - Method in class com.aol.cyclops.sequence.ReversedIterator
 
groupBy(Function<? super T, ? extends K>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asyncrhonous groupBy operation
groupBy(Function<? super T, ? extends K>, Collector<? super T, A, D>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asyncrhonous groupBy operation
groupBy(Function<? super T, ? extends K>, Supplier<M>, Collector<? super T, A, D>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asyncrhonous groupBy operation
groupBy(Function<? super T, ? extends K>) - Method in interface com.aol.cyclops.sequence.SequenceM
Use classifier function to group elements in this Sequence into a Map
groupBy(Function<? super T, ? extends K>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Use classifier function to group elements in this Sequence into a Map
grouped(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Group elements in a Stream
grouped(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Group elements in a Stream

H

head() - Method in class com.aol.cyclops.sequence.HeadAndTail
 
head() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3,4,5).head() //1
HeadAndTail<T> - Class in com.aol.cyclops.sequence
 
HeadAndTail() - Constructor for class com.aol.cyclops.sequence.HeadAndTail
 
headAndTail() - Method in interface com.aol.cyclops.sequence.SequenceM
extract head and tail together, where head is expected to be present
headAndTailOptional() - Method in interface com.aol.cyclops.sequence.SequenceM
extract head and tail together, where no head or tail may be present
HotStream<T> - Interface in com.aol.cyclops.sequence
 
hotStream(Executor) - Method in interface com.aol.cyclops.sequence.SequenceM
Turns this SequenceM into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
hotStream(Executor) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Turns this Streamable into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
HOUR - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
hours - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

I

innerJoin(Stream<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
innerJoin(Streamable<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
insertAt(int, T...) - Method in interface com.aol.cyclops.sequence.SequenceM
Insert data into a stream at given position
insertAt(int, T...) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Insert data into a stream at given position
insertStreamableAt(int, Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Insert a Stream into the middle of this stream at the specified position
insertStreamAt(int, Stream<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Insert a Stream into the middle of this stream at the specified position
instance - Static variable in interface com.aol.cyclops.monad.AnyMFactory
 
instance - Static variable in interface com.aol.cyclops.sequence.SequenceMFactory
 
intersperse(T) - Method in interface com.aol.cyclops.sequence.SequenceM
Returns a stream with a given value interspersed between any two values of this stream.
intersperse(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Returns a stream with a given value interspersed between any two values of this stream.
IntOperators<T> - Interface in com.aol.cyclops.sequence.future
 
invert() - Method in interface com.aol.cyclops.sequence.spliterators.ReversableSpliterator
 
invert() - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
invert() - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
invert() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
invert() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
isCurrentTaskComplete() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
 
isEmpty() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
isLeapYear(int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
isReverse() - Method in interface com.aol.cyclops.sequence.spliterators.ReversableSpliterator
 
isSatisfiedBy(Date) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Indicates whether the given date satisfies the cron expression.
isStreamComplete() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
 
isValidExpression(String) - Static method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Indicates whether the specified cron expression can be parsed into a valid cron expression
iterate(T, UnaryOperator<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
 
iterate(T, UnaryOperator<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
 
iterator() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 

J

jitter(long) - Method in interface com.aol.cyclops.sequence.SequenceM
Introduce a random jitter / time delay between the emission of elements
jitter(long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Introduce a random jitter / time delay between the emission of elements
join(CharSequence) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
join() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous join operation
join(CharSequence, CharSequence, CharSequence) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous join operation
join() - Method in interface com.aol.cyclops.sequence.SequenceM
assertEquals("123".length(),SequenceM.of(1, 2, 3).join().length());
join(String) - Method in interface com.aol.cyclops.sequence.SequenceM
assertEquals("1, 2, 3".length(), SequenceM.of(1, 2, 3).join(", ").length());
join(String, String, String) - Method in interface com.aol.cyclops.sequence.SequenceM
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
join() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertEquals("123".length(),Streamable.of(1, 2, 3).join().length());
join(String) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertEquals("1, 2, 3".length(), Streamable.of(1, 2, 3).join(", ").length());
join(String, String, String) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());

L

lastdayOffset - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
lastdayOfMonth - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
lastdayOfWeek - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
lastValue() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
leftOuterJoin(Stream<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
leftOuterJoin(Streamable<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
liftAndBind(Function<? super T, ?>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a bind operation (@see #bind) but also lift the return value into a Monad using configured MonadicConverters Note the modified javaslang monad laws are not applied during the looser typed bind operation The modification being used to work around the limits of the Java type system.
liftM(Function<U, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a function so it accepts an AnyM and returns an AnyM (any monad) AnyM view simplifies type related challenges.
liftM2(BiFunction<U1, U2, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a function so it accepts a Monad and returns a Monad (simplex view of a wrapped Monad) AnyM view simplifies type related challenges.
liftM2(Function<U1, Function<U2, R>>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a Curried Function into Monadic form
liftM3(Function3<U1, U2, U3, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a jOOλ Function3 into Monadic form.
liftM3(Function<U1, Function<U2, Function<U3, R>>>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a Curried Function into Monadic form
liftM4(Function4<U1, U2, U3, U4, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a jOOλ Function4 into Monadic form.
liftM4(Function<U1, Function<U2, Function<U3, Function<U4, R>>>>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a Curried Function into Monadic form
liftM5(Function5<U1, U2, U3, U4, U5, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a jOOλ Function5 (5 parameters) into Monadic form
liftM5(Function<U1, Function<U2, Function<U3, Function<U4, Function<U5, R>>>>>) - Static method in interface com.aol.cyclops.monad.AnyM
Lift a Curried Function (5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) ) into Monadic form
limit(long) - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Return all elements until specified time period has elapsed
limit(long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Return all elements until specified time period has elapsed
limitLast(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Limit results to the last x elements in a SequenceM
limitLast(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Limit results to the last x elements in a Streamable
limitUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Take elements from the Stream until the predicate returns true, after which all elements are excluded.
limitUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
limitWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
limitWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
listFromCollection(Iterable<Collection<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
listFromCompletableFuture(Iterable<CompletableFuture<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing CompletableFutures and convert them into a List of AnyMs e.g.
listFromIterable(Iterable<Iterable<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
listFromIterator(Iterable<Iterator<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
listFromOptional(Iterable<Optional<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Optionals and convert them into a List of AnyMs e.g.
listFromStream(Iterable<Stream<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Streams and convert them into a List of AnyMs e.g.
listFromStreamable(Iterable<Streamable<T>>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing Streamables and convert them into a List of AnyMs e.g.
loadSubscriber() - Static method in class com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsLoader
 
LongOperators<T> - Interface in com.aol.cyclops.sequence.future
 

M

map(Function<? super T, ? extends R>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a map operation on the wrapped monad instance e.g.
map(Function<? super T, ? extends R>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
map(Function<? super T, ? extends R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Map the values in the Streamable from one set of values / types to another
mapReduce(Stream) - Method in interface com.aol.cyclops.sequence.Monoid
Map a given Stream to required type (via mapToType method), then reduce using this monoid Example of multiple reduction using multiple Monoids and PowerTuples
mapReduce(Monoid<R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
mapReduce(Function<? super T, ? extends R>, Monoid<R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
mapReduce(Monoid<R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
mapReduce(Function<? super T, ? extends R>, Monoid<R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
mapToType(Stream) - Method in interface com.aol.cyclops.sequence.Monoid
 
max(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asyncrhonous min operation
max(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
max(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
MAX_YEAR - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
maxBy(Function<T, U>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously capture the maximum value in this stream using the provided function
maxBy(Function<T, C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Extract the maximum as determined by the supplied function
maxBy(Function<T, C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Extract the maximum as determined by the supplied function
maxDouble(ToDoubleFunction<T>) - Method in interface com.aol.cyclops.sequence.future.DoubleOperators
Perform an asynchronous max operation
maxInt(ToIntFunction<T>) - Method in interface com.aol.cyclops.sequence.future.IntOperators
Perform an asynchronous max operation
maxLong(ToLongFunction<T>) - Method in interface com.aol.cyclops.sequence.future.LongOperators
Perform an asynchronous max operation
MetaFactory() - Constructor for class com.aol.cyclops.monad.AnyMFactory.MetaFactory
 
MetaFactory() - Constructor for class com.aol.cyclops.sequence.SequenceMFactory.MetaFactory
 
min(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asyncrhonous min operation
min(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
min(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
minBy(Function<T, U>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously capture the minimum value in this stream using the provided function
minBy(Function<T, C>) - Method in interface com.aol.cyclops.sequence.SequenceM
Extract the minimum as determined by supplied function
minBy(Function<T, C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Extract the minimum as determined by supplied function
minDouble(ToDoubleFunction<T>) - Method in interface com.aol.cyclops.sequence.future.DoubleOperators
Perform an asynchronous min operation
minInt(ToIntFunction<T>) - Method in interface com.aol.cyclops.sequence.future.IntOperators
Perform an asynchronous min operation
minLong(ToLongFunction<T>) - Method in interface com.aol.cyclops.sequence.future.LongOperators
Perform an asynchronous min operation
MINUTE - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
minutes - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
monad() - Method in interface com.aol.cyclops.monad.AnyM
 
monad(Object) - Method in interface com.aol.cyclops.monad.AnyMFactory
 
Monoid<T> - Interface in com.aol.cyclops.sequence
An interoperability trait for Monoids Also inteded for use with Java 8 Streams (reduce method) Practically the method signature to reduce matches the Monoid interface Monoids could regrarded as immutable equivalents to JDK Collectors for Immutable Reduction
MONTH - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
monthMap - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
months - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

N

nearestWeekday - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
NO_SPEC - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
NO_SPEC_INT - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
noneMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Perform an asynchronous Any Match operation
noneMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
noneMatch(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
nthdayOfWeek - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

O

of(Object) - Method in interface com.aol.cyclops.monad.AnyMFactory
 
of(T, Function<T, Function<T, T>>, Function<?, T>) - Static method in interface com.aol.cyclops.sequence.Monoid
 
of(T, Function<T, Function<T, T>>) - Static method in interface com.aol.cyclops.sequence.Monoid
 
of(T, BiFunction<T, T, T>) - Static method in interface com.aol.cyclops.sequence.Monoid
 
of(T...) - Static method in interface com.aol.cyclops.sequence.SequenceM
Create an efficiently reversable Sequence from the provided elements
of(T...) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Streamable that returns a Stream
ofConvertable(Object) - Static method in interface com.aol.cyclops.monad.AnyM
Take the supplied object and always attempt to convert it to a Monad type
ofMonad(Object) - Static method in interface com.aol.cyclops.monad.AnyM
Take the supplied object and wrap it inside an AnyM - must be a supported monad type already
ofMonadList(Iterable<Object>) - Static method in interface com.aol.cyclops.monad.AnyM
Take an iterable containing monads and convert it into a List of AnyMs Uses ofMonad to take the supplied object and wrap it inside an AnyM - must be a supported monad type already
ofNullable(Object) - Static method in interface com.aol.cyclops.monad.AnyM
Generate an AnyM that wraps an Optional from the provided nullable object
ofType(Class<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Keep only those elements in a stream that are of a given type.
ofType(Class<U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Keep only those elements in a stream that are of a given type.
onClose(Runnable) - Method in interface com.aol.cyclops.sequence.SequenceM
 
onEmpty(T) - Method in interface com.aol.cyclops.sequence.SequenceM
 
onEmpty(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
onEmptyGet(Supplier<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
onEmptyGet(Supplier<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
onEmptySwitch(Supplier<Stream<T>>) - Method in interface com.aol.cyclops.sequence.SequenceM
If this SequenceM is empty replace it with a another Stream
onEmptySwitch(Supplier<Streamable<T>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
If this Streamable is empty replace it with a another Stream
onEmptyThrow(Supplier<X>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
onEmptyThrow(Supplier<X>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
onePer(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
emit one element per time period
onePer(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
emit one element per time period

P

parallel() - Method in interface com.aol.cyclops.sequence.SequenceM
 
parallelContains(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
True if a streamable contains element t use paralleled stream underneath
partition(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Partition a Stream into two one a per element basis, based on predicate's boolean value
partitionSequence(Predicate<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Partition a Stream into two one a per element basis, based on predicate's boolean value
peek(Consumer<? super T>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a peek operation on the wrapped monad e.g.
peek(Consumer<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
peek(Consumer<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Peek at each value in a Streamable as it passes through unchanged
permutations() - Method in interface com.aol.cyclops.sequence.SequenceM
Generate the permutations based on values in the SequenceM Makes use of Streamable to store intermediate stages in a collection
permutations() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Generate the permutations based on values in the Streamable
prepend(T...) - Method in interface com.aol.cyclops.sequence.SequenceM
Prepend given values to the start of the Stream
prepend(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Prepend given values to the start of the Stream
prepend(T...) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Prepend given values to the start of the Stream
prependStream(Stream<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Prepend Stream to this SequenceM
prependStreamable(Streamable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Prepend Stream to this Streamable
publisher - Static variable in class com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsLoader
 

Q

quadruplicate() - Method in interface com.aol.cyclops.sequence.SequenceM
Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
quadruplicate() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 

R

range(int, int) - Static method in interface com.aol.cyclops.sequence.SequenceM
Create an efficiently reversable Sequence that produces the integers between start and end
range(int, int) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Create an efficiently reversable Sequence that produces the integers between start and end
rangeLong(long, long) - Static method in interface com.aol.cyclops.sequence.SequenceM
Create an efficiently reversable Sequence that produces the integers between start and end
rangeLong(long, long) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Create an efficiently reversable Sequence that produces the integers between start and end
ReactiveStreamsLoader - Class in com.aol.cyclops.sequence.reactivestreams
 
ReactiveStreamsLoader() - Constructor for class com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsLoader
 
ReactiveStreamsPublisher<T> - Interface in com.aol.cyclops.sequence.reactivestreams
 
ReactiveStreamsSubscriber<T> - Interface in com.aol.cyclops.sequence.reactivestreams
 
ReactiveStreamsTerminalFutureOperations<T> - Interface in com.aol.cyclops.sequence.reactivestreams
Interface for reactive-streams based terminal operations, requires simple-react to be on the classpath.
ReactiveStreamsTerminalOperations<T> - Interface in com.aol.cyclops.sequence.reactivestreams
Interface for reactive-streams based terminal operations, requires simple-react to be on the classpath.
ReactiveTask - Class in com.aol.cyclops.sequence.reactivestreams
Class that represents an active reactive-streams task
ReactiveTask() - Constructor for class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
 
recover(Function<Throwable, ? extends T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Recover from an exception with an alternative value
recover(Class<EX>, Function<EX, ? extends T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Recover from a particular exception type
recover(Function<Throwable, T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Recover from an exception with an alternative value
recover(Class<EX>, Function<EX, T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Recover from a particular exception type
reduce(U, BiFunction<U, ? super T, U>, BinaryOperator<U>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream reduction
reduce(BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream reduction
reduce(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream reduction
reduce(Stream<T>) - Method in interface com.aol.cyclops.sequence.Monoid
 
reduce(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
reduce(BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
reduce(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
reduce(U, BiFunction<U, ? super T, U>, BinaryOperator<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
reduce(Stream<? extends Monoid<T>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
reduce(Iterable<Monoid<T>>) - Method in interface com.aol.cyclops.sequence.SequenceM
Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
reduce(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
reduce(BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
reduce(T, BinaryOperator<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
reduce(U, BiFunction<U, ? super T, U>, BinaryOperator<U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
reduce(Stream<Monoid<T>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
reduce(Iterable<Monoid<T>>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
reduceM(Monoid<AnyM<T>>) - Method in interface com.aol.cyclops.monad.AnyM
Perform a reduction where NT is a (native) Monad type e.g.
ReduceM<T> - Interface in com.aol.cyclops.monad
 
reduceMCompletableFuture(Monoid<CompletableFuture<T>>) - Method in interface com.aol.cyclops.monad.ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
reduceMIterable(Monoid<Iterable<T>>) - Method in interface com.aol.cyclops.monad.ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
reduceMOptional(Monoid<Optional<T>>) - Method in interface com.aol.cyclops.monad.ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
reduceMStream(Monoid<Stream<T>>) - Method in interface com.aol.cyclops.monad.ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
reduceMStreamable(Monoid<Streamable<T>>) - Method in interface com.aol.cyclops.monad.ReduceM
Perform a reduction where NT is a (native) Monad type e.g.
reducer() - Method in interface com.aol.cyclops.sequence.Monoid
 
Reducers - Class in com.aol.cyclops.sequence
 
Reducers() - Constructor for class com.aol.cyclops.sequence.Reducers
 
remove(T) - Method in interface com.aol.cyclops.sequence.SequenceM
Remove all occurances of the specified element from the SequenceM
remove(T) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Remove all occurances of the specified element from the SequenceM
replicateM(int) - Method in interface com.aol.cyclops.monad.AnyM
Replicate given Monad
request(long) - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
 
requestAll() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
Request all elements to be processed from the processing Stream
requestAllAsync() - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
Request all elements to be processed asynchronously in the processing stream
requestAsync(long) - Method in class com.aol.cyclops.sequence.reactivestreams.ReactiveTask
Asyncrhonously request more elements from the Stream
retry(Function<? super T, ? extends R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Retry a transformation if it fails.
retry(Function<T, R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Retry a transformation if it fails.
reveresedSequenceM() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
reveresedStream() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
ReversableSpliterator - Interface in com.aol.cyclops.sequence.spliterators
 
reverse() - Method in interface com.aol.cyclops.sequence.SequenceM
 
reverse(Stream<U>) - Static method in class com.aol.cyclops.sequence.SeqUtils
Reverse a Stream
reverse() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
ReversedIterator<U> - Class in com.aol.cyclops.sequence
 
ReversedIterator() - Constructor for class com.aol.cyclops.sequence.ReversedIterator
 
reversedIterator() - Method in class com.aol.cyclops.sequence.ReversedIterator
 
reversedListOf(List<T>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
reversedListOf(List<T>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
reversedOf(T...) - Static method in interface com.aol.cyclops.sequence.SequenceM
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
reversedOf(T...) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
reversedStream(List<U>) - Static method in class com.aol.cyclops.sequence.SeqUtils
Create a reversed Stream from a List
ReversingArraySpliterator<T> - Class in com.aol.cyclops.sequence.spliterators
 
ReversingArraySpliterator() - Constructor for class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
ReversingListSpliterator<T> - Class in com.aol.cyclops.sequence.spliterators
 
ReversingListSpliterator(List<T>, boolean) - Constructor for class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
ReversingRangeIntSpliterator - Class in com.aol.cyclops.sequence.spliterators
 
ReversingRangeIntSpliterator() - Constructor for class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
ReversingRangeLongSpliterator - Class in com.aol.cyclops.sequence.spliterators
 
ReversingRangeLongSpliterator() - Constructor for class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
rightOuterJoin(Stream<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
rightOuterJoin(Streamable<U>, BiPredicate<T, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 

S

scanLeft(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Scan left using supplied Monoid
scanLeft(U, BiFunction<U, ? super T, U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Scan left
scanLeft(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Scan left using supplied Monoid
scanLeft(U, BiFunction<U, ? super T, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Scan left
scanRight(Monoid<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Scan right
scanRight(U, BiFunction<? super T, U, U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Scan right
scanRight(Monoid<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Scan right
scanRight(U, BiFunction<? super T, U, U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Scan right
schedule(String, ScheduledExecutorService) - Method in interface com.aol.cyclops.sequence.SequenceM
Execute this Stream on a schedule
scheduleFixedDelay(long, ScheduledExecutorService) - Method in interface com.aol.cyclops.sequence.SequenceM
Execute this Stream on a schedule
scheduleFixedRate(long, ScheduledExecutorService) - Method in interface com.aol.cyclops.sequence.SequenceM
Execute this Stream on a schedule
SECOND - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
seconds - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
sequence(Collection<AnyM<T1>>) - Static method in interface com.aol.cyclops.monad.AnyM
Convert a Collection of Monads to a Monad with a List
sequence(Stream<AnyM<T1>>) - Static method in interface com.aol.cyclops.monad.AnyM
Convert a Stream of Monads to a Monad with a List
sequence(Collection<AnyM<T1>>) - Method in interface com.aol.cyclops.monad.AnyMFunctions
 
sequence(Stream<AnyM<T1>>) - Method in interface com.aol.cyclops.monad.AnyMFunctions
 
sequenceM() - Method in interface com.aol.cyclops.sequence.reactivestreams.CyclopsSubscriber
 
SequenceM<T> - Interface in com.aol.cyclops.sequence
 
sequenceM(Stream<T>, ReversableSpliterator) - Method in interface com.aol.cyclops.sequence.SequenceMFactory
 
sequenceM() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
SequenceMFactory - Interface in com.aol.cyclops.sequence
 
SequenceMFactory.MetaFactory - Class in com.aol.cyclops.sequence
 
sequential() - Method in interface com.aol.cyclops.sequence.SequenceM
 
SeqUtils - Class in com.aol.cyclops.sequence
 
SeqUtils() - Constructor for class com.aol.cyclops.sequence.SeqUtils
 
setCalendarHour(Calendar, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Advance the calendar to the particular hour paying particular attention to daylight saving problems.
setReverse(boolean) - Method in interface com.aol.cyclops.sequence.spliterators.ReversableSpliterator
 
setTimeZone(TimeZone) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Sets the time zone for which this CronExpression will be resolved.
shuffle() - Method in interface com.aol.cyclops.sequence.SequenceM
 
shuffle(Random) - Method in interface com.aol.cyclops.sequence.SequenceM
 
shuffle() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
shuffle(Random) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
single() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
single(Predicate<T>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
single() - Method in interface com.aol.cyclops.sequence.SequenceM
//1 SequenceM.of(1).single(); //UnsupportedOperationException SequenceM.of().single(); //UnsupportedOperationException SequenceM.of(1,2,3).single();
single(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
single() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(1).single(),equalTo(1));
singleOptional() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
 
singleOptional() - Method in interface com.aol.cyclops.sequence.SequenceM
//Optional[1] SequenceM.of(1).singleOptional(); //Optional.empty SequenceM.of().singleOpional(); //Optional.empty SequenceM.of(1,2,3).singleOptional();
size() - Method in interface com.aol.cyclops.sequence.SequenceM
[equivalent to count]
size() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
[equivalent to count]
skip(long) - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Skip all elements until specified time period has passed
skip(long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Skip all elements until specified time period has passed
skipLast(int) - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
skipLast(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
skipUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Drop elements from the Stream until the predicate returns true, after which all elements are included
skipUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
skipWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
skipWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
skipWhiteSpace(int, String) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
slice(long, long) - Method in interface com.aol.cyclops.sequence.SequenceM
 
slice(long, long) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
sliding(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a sliding view over this Sequence
sliding(int, int) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a sliding view over this Sequence
sliding(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a sliding view over this Sequence
sliding(int, int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a sliding view over this Sequence
sorted() - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
assertThat(SequenceM.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
sorted(Function<? super T, ? extends U>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
sorted() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted(Comparator<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertThat(Streamable.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
sorted(Function<? super T, ? extends U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
splitAt(int) - Method in interface com.aol.cyclops.sequence.SequenceM
Split at supplied location
splitAt(int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Split at supplied location
splitAtHead() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Split this Streamable after the first element (if present)
splitBy(Predicate<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Split stream at point where predicate no longer holds
splitBy(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Split stream at point where predicate no longer holds
splitSequenceAtHead() - Method in interface com.aol.cyclops.sequence.SequenceM
Split a Stream at it's head (similar to headAndTail)
startsWith(Iterable<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
startsWith(Iterator<T>) - Method in interface com.aol.cyclops.sequence.SequenceM
assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))
startsWith(Iterable<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
startsWith(Iterator<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))
storeExpressionVals(int, String, int) - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
stream() - Method in interface com.aol.cyclops.monad.AnyM
 
stream() - Method in class com.aol.cyclops.sequence.ReversedIterator
 
stream() - Method in interface com.aol.cyclops.sequence.SequenceM
Convert this SequenceM into a Stream
stream() - Method in interface com.aol.cyclops.sequence.streamable.ToStream
 
Streamable<T> - Interface in com.aol.cyclops.sequence.streamable
Represents something that can generate a Stream, repeatedly
StreamableImpl<T> - Class in com.aol.cyclops.sequence.streamable
 
StreamableImpl() - Constructor for class com.aol.cyclops.sequence.streamable.StreamableImpl
 
streamOf(T...) - Static method in interface com.aol.cyclops.monad.AnyM
Create an AnyM wrapping a Stream of the supplied data Identical to fromArray, exists as it may appear functionally more obvious to users than fromArray (which fits the convention)
subscribe(Stream<T>, Subscriber<? super T>) - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsPublisher
 
subscribe() - Method in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsSubscriber
 
subscriber - Static variable in class com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsLoader
 
subscriber() - Static method in interface com.aol.cyclops.sequence.SequenceM
Create a subscriber that can listen to Reactive Streams (simple-react, RxJava AkkaStreams, Kontraktor, QuadarStreams etc)
subStream(int, int) - Method in interface com.aol.cyclops.sequence.SequenceM
Return a Stream with elements before the provided start index removed, and elements after the provided end index removed
subStream(int, int) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Return a Streamable with elements before the provided start index removed, and elements after the provided end index removed
sumDouble(ToDoubleFunction<T>) - Method in interface com.aol.cyclops.sequence.future.DoubleOperators
Perform an asynchronous sum operation
sumInt(ToIntFunction<T>) - Method in interface com.aol.cyclops.sequence.future.IntOperators
Perform an asynchronous sum operation
sumLong(ToLongFunction<T>) - Method in interface com.aol.cyclops.sequence.future.LongOperators
Perform an asynchronous sum operation
summaryStatisticsDouble(ToDoubleFunction<T>) - Method in interface com.aol.cyclops.sequence.future.DoubleOperators
Perform an asynchronous summaryStatistics operation
summaryStatisticsInt(ToIntFunction<T>) - Method in interface com.aol.cyclops.sequence.future.IntOperators
Perform an asynchronous summaryStatistics operation
summaryStatisticsLong(ToLongFunction<T>) - Method in interface com.aol.cyclops.sequence.future.LongOperators
Perform an asynchronous summaryStatistics operation
synchronizedFromIterable(Iterable<T>) - Static method in class com.aol.cyclops.sequence.streamable.AsStreamable
 
synchronizedFromStream(Stream<T>) - Static method in class com.aol.cyclops.sequence.streamable.AsStreamable
 

T

tail() - Method in class com.aol.cyclops.sequence.HeadAndTail
 
tail() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3,4,5).tail() //Streamable[2,3,4,5]
tailStream() - Method in class com.aol.cyclops.sequence.HeadAndTail
 
timestamp() - Method in interface com.aol.cyclops.sequence.SequenceM
SequenceM.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)
timestamp() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)
toArray(IntFunction<A[]>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asyncrhonously generate an Array
toArray() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asyncrhonously generate an Array
toArray() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
toArray(IntFunction<A[]>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
toCollection(Supplier<C>) - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously perform a Stream collection
toCollection(Supplier<C>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
toCollection(Supplier<C>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Add the contents of this Stream to the mutable collection supplied by the provided collectionFactory
toCompletableFuture() - Method in interface com.aol.cyclops.monad.AnyM
 
toCompletableFuture() - Method in interface com.aol.cyclops.sequence.SequenceM
CompletableFuture<List<String>> cf = SequenceM.of("hello","world") .toCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
toCompletableFuture() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
CompletableFuture<List<String>> cf = Streamable.of("hello","world") .toCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
toConcurrentLazyCollection() - Method in interface com.aol.cyclops.sequence.SequenceM
Lazily converts this SequenceM into a Collection.
toConcurrentLazyCollection(Stream<A>) - Static method in class com.aol.cyclops.sequence.SeqUtils
Lazily constructs a Collection from specified Stream.
toConcurrentLazyCollection(Iterator<A>) - Static method in class com.aol.cyclops.sequence.SeqUtils
 
toConcurrentLazyCollection() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Lazily converts this Streamable into a Collection.
toConcurrentLazyStreamable() - Method in interface com.aol.cyclops.sequence.SequenceM
Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6) .map(i->i+2) .toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12))); assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12)));
toCountDouble() - Static method in class com.aol.cyclops.sequence.Reducers
 
toCountInt() - Static method in class com.aol.cyclops.sequence.Reducers
 
toLazyCollection() - Method in interface com.aol.cyclops.sequence.SequenceM
Lazily converts this SequenceM into a Collection.
toLazyCollection(Stream<A>) - Static method in class com.aol.cyclops.sequence.SeqUtils
Projects an immutable collection of this stream.
toLazyCollection(Iterator<A>) - Static method in class com.aol.cyclops.sequence.SeqUtils
 
toLazyCollection() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Lazily converts this Streamable into a Collection.
toList() - Method in interface com.aol.cyclops.monad.AnyM
Convert this monad into a List
toList() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously convert this Stream into a List
toList() - Method in interface com.aol.cyclops.sequence.SequenceM
 
toList() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Streamable.of(1,2,3) .toList(); //List[1,2,3]
toOptional() - Method in interface com.aol.cyclops.monad.AnyM
 
toOptional() - Method in interface com.aol.cyclops.sequence.SequenceM
Type safe unwrap
toOptional() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Type safe unwrap
toPMap() - Static method in class com.aol.cyclops.sequence.Reducers
 
toPStack() - Static method in class com.aol.cyclops.sequence.Reducers
 
toSequence(Function<T, Stream<NT>>) - Method in interface com.aol.cyclops.monad.AnyM
Sequence the contents of a Monad.
toSequence() - Method in interface com.aol.cyclops.monad.AnyM
Optional<List<Integer>> into Stream<Integer>
toSet() - Method in interface com.aol.cyclops.monad.AnyM
Convert this monad into a Set
toSet() - Method in interface com.aol.cyclops.sequence.future.FutureOperations
Asynchronously convert this Stream into a List
toSet() - Method in interface com.aol.cyclops.sequence.SequenceM
 
toSet() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
toStream() - Method in interface com.aol.cyclops.sequence.SequenceM
Convert this SequenceM into a Stream
ToStream<T> - Interface in com.aol.cyclops.sequence.streamable
 
toStreamable() - Method in interface com.aol.cyclops.sequence.SequenceM
Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6) .map(i->i*2) .toStreamable(); repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));
toString() - Method in interface com.aol.cyclops.monad.AnyM
 
toString() - Method in class com.aol.cyclops.scheduling.util.cron.CronExpression
Returns the string representation of the CronExpression
toString(String) - Static method in class com.aol.cyclops.sequence.Reducers
 
toTotalDouble() - Static method in class com.aol.cyclops.sequence.Reducers
 
toTotalInt() - Static method in class com.aol.cyclops.sequence.Reducers
 
traverse(Collection<AnyM<T>>, Function<T, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Convert a Collection of Monads to a Monad with a List applying the supplied function in the process
traverse(Stream<AnyM<T>>, Function<T, R>) - Static method in interface com.aol.cyclops.monad.AnyM
Convert a Stream of Monads to a Monad with a List applying the supplied function in the process
traverse(Collection<AnyM<T>>, Function<T, R>) - Method in interface com.aol.cyclops.monad.AnyMFunctions
 
traverse(Stream<AnyM<T>>, Function<T, R>) - Method in interface com.aol.cyclops.monad.AnyMFunctions
 
triplicate() - Method in interface com.aol.cyclops.sequence.SequenceM
Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
triplicate() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
tryAdvance(Consumer<? super T>) - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
tryAdvance(Consumer<? super T>) - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
tryAdvance(IntConsumer) - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
tryAdvance(LongConsumer) - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 
trySplit() - Method in class com.aol.cyclops.sequence.spliterators.ReversingArraySpliterator
 
trySplit() - Method in class com.aol.cyclops.sequence.spliterators.ReversingListSpliterator
 
trySplit() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeIntSpliterator
 
trySplit() - Method in class com.aol.cyclops.sequence.spliterators.ReversingRangeLongSpliterator
 

U

unapply() - Method in interface com.aol.cyclops.objects.Decomposable
 
unit(T) - Method in interface com.aol.cyclops.monad.AnyM
Construct a new instanceof AnyM using the type of the underlying wrapped monad
unordered() - Method in interface com.aol.cyclops.sequence.SequenceM
 
unwrap() - Method in interface com.aol.cyclops.monad.AnyM
 
unwrap() - Method in class com.aol.cyclops.objects.AsDecomposable.CoercedDecomposable
 
unwrap() - Method in interface com.aol.cyclops.objects.Decomposable
 
unwrap() - Method in interface com.aol.cyclops.sequence.SequenceM
 
unwrap() - Method in interface com.aol.cyclops.sequence.Unwrapable
 
Unwrapable - Interface in com.aol.cyclops.sequence
 
unzip(SequenceM<Tuple2<T, U>>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Unzip a zipped Stream
unzip(Streamable<Tuple2<T, U>>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Unzip a zipped Stream
unzip3(SequenceM<Tuple3<T1, T2, T3>>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Unzip a zipped Stream into 3
unzip3(Streamable<Tuple3<T1, T2, T3>>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Unzip a zipped Stream into 3
unzip4(SequenceM<Tuple4<T1, T2, T3, T4>>) - Static method in interface com.aol.cyclops.sequence.SequenceM
Unzip a zipped Stream into 4
unzip4(Streamable<Tuple4<T1, T2, T3, T4>>) - Static method in interface com.aol.cyclops.sequence.streamable.Streamable
Unzip a zipped Stream into 4

V

validateExpression(String) - Static method in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

W

windowBySizeAndTime(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated up to a max size, or for max period of time
windowBySizeAndTime(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated up to a max size, or for max period of time
windowByTime(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated within a specified time window
windowByTime(long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create Streamable of Streamables (replayable Streams / Sequences) where each Streamable is populated within a specified time window
windowStatefullyWhile(BiPredicate<Streamable<? super T>, ? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
windowStatefullyWhile(BiPredicate<Streamable<? super T>, ? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create Streamable of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
windowUntil(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated until the supplied predicate holds.
windowUntil(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated until the supplied predicate holds.
windowWhile(Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied predicate holds.
windowWhile(Predicate<T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied predicate holds.

X

xMatch(int, Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.SequenceM
Check that there are specified number of matches of predicate in the Stream
xMatch(int, Predicate<? super T>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Check that there are specified number of matches of predicate in the Stream
xPer(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.SequenceM
emit x elements per time period
xPer(int, long, TimeUnit) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
emit x elements per time period

Y

YEAR - Static variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 
years - Variable in class com.aol.cyclops.scheduling.util.cron.CronExpression
 

Z

zero() - Method in interface com.aol.cyclops.sequence.Monoid
An element that when provided as a parameter to the combiner with another value, results in the other value being returned e.g.
zip(Seq<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Zip 2 streams into one
zip(Seq<U>, BiFunction<T, U, R>) - Method in interface com.aol.cyclops.sequence.SequenceM
 
zip(Streamable<U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Zip 2 streams into one
zip(Streamable<U>, BiFunction<T, U, R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
 
zip3(Stream<? extends S>, Stream<? extends U>) - Method in interface com.aol.cyclops.sequence.SequenceM
zip 3 Streams into one
zip3(Streamable<? extends S>, Streamable<? extends U>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
zip 3 Streams into one
zip4(Stream<T2>, Stream<T3>, Stream<T4>) - Method in interface com.aol.cyclops.sequence.SequenceM
zip 4 Streams into 1
zip4(Streamable<T2>, Streamable<T3>, Streamable<T4>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
zip 4 Streams into 1
zipAnyM(AnyM<? extends S>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Zip this SequenceM against any monad type.
zipAnyM(AnyM<? extends S>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Zip this Streamable against any monad type.
zipSequence(SequenceM<? extends S>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Generic zip function.
zipStream(Stream<U>) - Method in interface com.aol.cyclops.sequence.SequenceM
Zip 2 streams into one
zipStream(BaseStream<? extends S, ? extends BaseStream<? extends S, ?>>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.SequenceM
Zip this Monad with a Stream
zipStream(BaseStream<? extends S, ? extends BaseStream<? extends S, ?>>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Zip this Monad with a Stream
zipStreamable(Streamable<? extends S>, BiFunction<? super T, ? super S, ? extends R>) - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Generic zip function.
zipWithIndex() - Method in interface com.aol.cyclops.sequence.SequenceM
Add an index to the current Stream
zipWithIndex() - Method in interface com.aol.cyclops.sequence.streamable.Streamable
Add an index to the current Stream
A B C D E F G H I J L M N O P Q R S T U V W X Y Z 
Skip navigation links