com.aol.cyclops.types

Interface TransformerTraversable<T>

Type Parameters:

T - Data type of the elements stored inside the traversable manipulated by this monad transformer

All Known Subinterfaces:

AnyMSeq<T>, CollectionX<T>, ConvertableSequentialFunctor<T>, DequeX<T>, ExtendedTraversable<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>

All Known Implementing Classes:

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

public interface TransformerTraversable<T>

Represents a Traversable Monad Transformer, the monad transformer instance manipulates a nested non-scalar data type

Method Summary

Modifier and Type	Method and Description
default ListTSeq<T>	groupedStatefullyUntilT(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate) List Transformer view into batched Lists where each List is populated while the supplied bipredicate holds.
default ListTSeq<T>	groupedT(int groupSize) Group the elements in this Traversable into batches of the provided size.
default ListTSeq<T>	groupedUntilT(java.util.function.Predicate<? super T> predicate) Create a Traversable batched by List, where each batch is populated until the predicate holds.
default ListTSeq<T>	groupedWhileT(java.util.function.Predicate<? super T> predicate) Create a Traversable batched by List, where each batch is populated while the predicate holds.
default ListTSeq<T>	slidingT(int windowSize) Create a Sliding window into the data in this traversble.
default ListTSeq<T>	slidingT(int windowSize, int increment) Create a Sliding window into the data in this traversble.
ReactiveSeq<T>	stream()

Method Detail

groupedT

default ListTSeq<T> groupedT(int groupSize)

Group the elements in this Traversable into batches of the provided size. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.

 
   ListTSeq<Integer> transformer = ReactiveSeq.of(2,1,3,4,5,7,6,8,9,10)
                                              .groupedT(4);
   
   //ReactiveSeq[List[2,1,3,4],List[5,7,6,8],List[9,10]]
   
  ListTSeq<ListX<Integer>> nested = transformer.map(i->i*2)
                                               .sorted()
                                               .grouped(2);   
   
  //ReactiveSeq[List[List[2,4],List[6,8]],List[List[10,14],List[12,16]],List[List[18,20]]]
       
       

Parameters:

groupSize - Size of each batch of elements to be grouped into Lists

Returns:

List Transformer view into batched / grouped data

slidingT

default ListTSeq<T> slidingT(int windowSize,
                             int increment)

Create a Sliding window into the data in this traversble. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.

  
  ListTSeq<Integer> sliding = ListX.of(1,2,3,4,5,6,7)
                                   .sliding(3,2);
 
  //ReactiveSeq[List[1,2,3],List[3,4,5],List[5,6,7],List[7]]
 
 

Parameters:

windowSize - Size of sliding window

increment - Increment between windows

Returns:

List Transformer view into the Sliding windows

slidingT

default ListTSeq<T> slidingT(int windowSize)

Create a Sliding window into the data in this traversble. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists. ( @see TransformerTraversable#grouped(int) )

        
        ListTSeq<Integer> sliding = ListX.of(1,2,3,4,5,6,7)
                                         .sliding(3);
       
       //ReactiveSeq[List[1,2,3],List[2,3,4],List[4,5,6],List[6,7]]
       
       

Parameters:

windowSize - Size of sliding window

Returns:

List Transformer view into the Sliding windows

groupedUntilT

default ListTSeq<T> groupedUntilT(java.util.function.Predicate<? super T> predicate)

Create a Traversable batched by List, where each batch is populated until the predicate holds. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.

  
  ListTSeq<Integer> grouped = ReactiveSeq.of(1,2,3,4,5,6)
                                         .groupedWhile(i->i%3!=0)
                                         .toList();
                                         
  //ReactiveSeq[List[1,2,3],List[4,5,6]]                                       
  
 
 

Parameters:

predicate - Predicate to determine batch termination point

Returns:

List Transformer view into batched Traversable

groupedStatefullyUntilT

default ListTSeq<T> groupedStatefullyUntilT(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

List Transformer view into batched Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window

Parameters:

predicate - Predicate to determine batch

Returns:

List Transformer view into batched Traversable

groupedWhileT

default ListTSeq<T> groupedWhileT(java.util.function.Predicate<? super T> predicate)

Create a Traversable batched by List, where each batch is populated while the predicate holds. A List Transformer view into the data will be provided, ListTransformers allow nested Lists to be manipulated directly. The data will remain nested (as List's inside the current Traversable), but the ListTransformer will be able to operate aggregate operations across all nested Lists, each operation on the List Transformer is applied, by the transformer to all Lists.

  
  ListTSeq<Integer> grouped = ReactiveSeq.of(1,2,3,4,5,6,7,8,9,5)
                                         .groupedUntil(i->i==5)
                                         .toList();
                                         
  //ReactiveSeq[List[1,2,3,4,5],List[6,7,8,9,5]]                                       
  
 
 

Parameters:

predicate - Predicate to determine batch termination point

Returns:

List Transformer view into batched Traversable

stream

ReactiveSeq<T> stream()