com.aol.cyclops.types

Interface IterableFunctor<T>

All Superinterfaces:

ConvertableSequence<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>, Traversable<T>

All Known Subinterfaces:

AnyMSeq<T>, CollectionX<T>, DequeX<T>, FluentCollectionX<T>, FluentSequenceX<T>, LazyFutureStream<U>, ListX<T>, MutableCollectionX<T>, MutableSequenceX<T>, PBagX<T>, PersistentCollectionX<T>, POrderedSetX<T>, PQueueX<T>, PSetX<T>, PStackX<T>, PVectorX<T>, QueueX<T>, ReactiveSeq<T>, SetX<T>, SortedSetX<T>, Streamable<T>, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl, CollectionXImpl, DequeXImpl, LazyFutureStreamImpl, ListXImpl, MaterializedList, PBagXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl, QueueXImpl, ReactiveSeqImpl, ReversedIterator, SetXImpl, SortedSetXImpl, StreamableImpl

public interface IterableFunctor<T>
extends java.lang.Iterable<T>, Functor<T>, Foldable<T>, Traversable<T>, ConvertableSequence<T>

Method Summary

Modifier and Type	Method and Description
default org.jooq.lambda.Collectable<T>	collectable()
default <R> ReactiveSeq<R>	flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, FlatMapConfig) method to subscribe asynchronously also.
default <R> ReactiveSeq<R>	flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, FlatMapConfig) method to subscribe asynchronously also.
default <R> ReactiveSeq<R>	flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, QueueFactory<R> factory) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the @see FlatMapConfig class to configure an executor for asynchronous subscription.
<R> IterableFunctor<R>	map(java.util.function.Function<? super T,? extends R> fn)
default ReactiveSeq<T>	mergePublisher(java.util.Collection<? extends org.reactivestreams.Publisher<T>> publishers) A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#mergeublisher(Collection, FlatMapConfig) method to subscribe asynchronously also.
default ReactiveSeq<T>	mergePublisher(java.util.Collection<? extends org.reactivestreams.Publisher<T>> publishers, QueueFactory<T> factory) A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the @see FlatMapConfig class to configure an executor for asynchronous subscription.
default ReactiveSeq<T>	stream()
<U> IterableFunctor<U>	unitIterator(java.util.Iterator<U> U)

Methods inherited from interface com.aol.cyclops.types.Functor

cast, patternMatch, peek, trampoline

Methods inherited from interface com.aol.cyclops.types.Traversable

combine, cycle, cycle, cycleUntil, cycleWhile, distinct, dropRight, dropUntil, dropWhile, endsWith, endsWithIterable, findAny, findFirst, firstValue, futureOperations, get, groupBy, grouped, grouped, grouped, grouped, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, headAndTail, intersperse, join, join, join, lazyOperations, limit, limitLast, limitUntil, limitWhile, onEmpty, onEmptyGet, onEmptyThrow, reverse, scanLeft, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, shuffle, shuffle, single, single, singleOptional, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, startsWith, startsWithIterable, subscribe, takeRight, takeUntil, takeWhile, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit, visit, zip, zip, zip3, zip4, zipStream, zipWithIndex

Methods inherited from interface com.aol.cyclops.types.Foldable

foldRight, foldRight, foldRight, foldRightMapToType, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

Method Detail

mergePublisher

default ReactiveSeq<T> mergePublisher(java.util.Collection<? extends org.reactivestreams.Publisher<T>> publishers)

A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#mergeublisher(Collection, FlatMapConfig) method to subscribe asynchronously also. Max concurrency is determined by the publishers collection size, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

publishers -

Returns:

mergePublisher

default ReactiveSeq<T> mergePublisher(java.util.Collection<? extends org.reactivestreams.Publisher<T>> publishers,
                                      QueueFactory<T> factory)

A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the @see FlatMapConfig class to configure an executor for asynchronous subscription. The QueueFactory parameter can be used to control the maximum queued elements @see QueueFactories

flatMapPublisher

default <R> ReactiveSeq<R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, FlatMapConfig) method to subscribe asynchronously also. A default limit of 10k active publishers is enforced, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

mapper -

Returns:

flatMapPublisher

default <R> ReactiveSeq<R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                            int maxConcurrency)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, FlatMapConfig) method to subscribe asynchronously also. Active publishers are limited by the maxConcurrency parameter, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

mapper -

Returns:

flatMapPublisher

default <R> ReactiveSeq<R> flatMapPublisher(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
                                            int maxConcurrency,
                                            QueueFactory<R> factory)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the @see FlatMapConfig class to configure an executor for asynchronous subscription. Active publishers are limited by the maxConcurrency parameter. The QueueFactory parameter can be used to control the maximum queued elements @see QueueFactories

unitIterator

<U> IterableFunctor<U> unitIterator(java.util.Iterator<U> U)

map

<R> IterableFunctor<R> map(java.util.function.Function<? super T,? extends R> fn)

Specified by:

map in interface Functor<T>

stream

default ReactiveSeq<T> stream()

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface Traversable<T>

collectable

default org.jooq.lambda.Collectable<T> collectable()