CachedValues (cyclops-tuples 7.2.3 API)

All Superinterfaces:

java.lang.Comparable<CachedValues>, com.aol.cyclops.objects.Decomposable, com.aol.cyclops.comprehensions.donotation.Doable, java.lang.Iterable, com.aol.cyclops.matcher.recursive.Matchable, com.aol.cyclops.sequence.streamable.ToStream, com.aol.cyclops.value.ValueObject

All Known Subinterfaces:

PTuple1<T1>, PTuple2<T1,T2>, PTuple3<T1,T2,T3>, PTuple4<T1,T2,T3,T4>, PTuple5<T1,T2,T3,T4,T5>, PTuple6<T1,T2,T3,T4,T5,T6>, PTuple7<T1,T2,T3,T4,T5,T6,T7>, PTuple8<T1,T2,T3,T4,T5,T6,T7,T8>

All Known Implementing Classes:

LazyMap1PTuple8, LazyMap2PTuple8, LazyMap3PTuple8, LazyMap4PTuple8, LazyMap5PTuple8, LazyMap6PTuple8, LazyMap7PTuple8, LazyMap8PTuple8, LazySwapPTuple2, LazySwapPTuple3, Memo1, Memo2, ReorderP1, TupleImpl
```
public interface CachedValues
extends java.lang.Iterable, com.aol.cyclops.value.ValueObject, com.aol.cyclops.sequence.streamable.ToStream, com.aol.cyclops.comprehensions.donotation.Doable, com.aol.cyclops.matcher.recursive.Matchable, java.lang.Comparable<CachedValues>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class CachedValues.ConvertStep<T extends CachedValues>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`CachedValues.ConvertStep<T extends CachedValues>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <T extends CachedValues,X> T`	`append(X value)`
`default <T extends CachedValues> T`	`appendAll(CachedValues values)`
`int`	`arity()`
`default <T,A,R> java.util.stream.Collector<T,A,R>`	`asCollector()` Wrap multiple collectors in a single Collector instance, so they can all run against a single Stream e.g `PTuple2<Set<Integer>,List<Integer>> res = Stream.of(1, 2, 2) .collect(tuple(Collectors.toSet(),Collectors.toList()).asCollector());` Filters all non-Collector instances out of the Tuple
`default <T extends java.util.stream.Stream<?>> T`	`asFlattenedStream()` Will attempt to convert each element in the tuple into a flattened Stream
`default <T extends CachedValues> com.aol.cyclops.sequence.Monoid<T>`	`asReducer()` Wrap multiple reducers or monoids into a single reducer instance, that can be used to reduce a given steam to multiple different values simultanously `Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b); Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b); val result = tuple(sum,mult).<PTuple2<Integer,Integer>>asReducer() .mapReduce(Stream.of(1,2,3,4)); assertThat(result,equalTo(tuple(10,24)));` Or alternatively `Monoid<String> concat = Monoid.of("",(a,b)->a+b); Monoid<String> join = Monoid.of("",(a,b)->a+","+b); Monoid<CachedValues> reducer = PowerTuples.tuple(concat,join).asReducer(); assertThat(Stream.of("hello", "world", "woo!").map(CachedValues::of) .reduce(reducer.zero(),reducer.reducer()) ,equalTo(tuple("helloworldwoo!",",hello,world,woo!")));`
`default java.util.stream.Stream<java.lang.String>`	`asStreamOfStrings()`
`default <T extends java.util.stream.Stream<?>> java.util.stream.Stream<T>`	`asStreams()` Will attempt to convert each element in the tuple into a Stream Collection::stream CharSequence to stream File to Stream URL to Stream
`default int`	`compareTo(CachedValues o)`
`default <T extends CachedValues> CachedValues.ConvertStep<T>`	`convert()`
`default <T extends CachedValues> T`	`filter(java.util.function.Predicate<PTuple2<java.lang.Integer,java.lang.Object>> p)`
`default <T extends CachedValues,X extends CachedValues> T`	`flatMap(java.util.function.Function<X,T> fn)`
`default void`	`forEach(java.util.function.Consumer c)`
`java.util.List<java.lang.Object>`	`getCachedValues()`
`default java.lang.Object`	`getMatchable()`
`default java.util.Iterator`	`iterator()`
`default <T extends CachedValues> T`	`map(java.util.function.Function<java.util.List,java.util.List> fn)`
`static CachedValues`	`of(java.lang.Object... values)`
`static <T> CachedValues`	`of(T value)`
`default java.util.stream.Stream`	`stream()`
`default <X> X`	`to(java.lang.Class<X> to)`
`default <T> java.util.List<T>`	`toList()`
`default <K,V> java.util.Map<K,V>`	`toMap()`
`CachedValues`	`withArity(int arity)`

Methods inherited from interface com.aol.cyclops.matcher.recursive.Matchable
listOfValues, matches, matches, matches, matches, matches, mayMatch, mayMatch, mayMatch, mayMatch, mayMatch, ofDecomposable, ofStream

Methods inherited from interface com.aol.cyclops.objects.Decomposable
unapply, unwrap

Methods inherited from interface com.aol.cyclops.sequence.streamable.ToStream
getStreamable, isEmpty, reveresedSequenceM, reveresedStream, sequenceM

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface com.aol.cyclops.comprehensions.donotation.Doable
doWithThisAnd, doWithThisAndThat, doWithThisAndThat, getValue

- Method Detail
  - getMatchable
```
default java.lang.Object getMatchable()
```
    Specified by:
    
    getMatchable in interface com.aol.cyclops.matcher.recursive.Matchable
  - getCachedValues
```
java.util.List<java.lang.Object> getCachedValues()
```
  - withArity
```
CachedValues withArity(int arity)
```
  - convert
```
default <T extends CachedValues> CachedValues.ConvertStep<T> convert()
```
  - to
```
default <X> X to(java.lang.Class<X> to)
```
  - asReducer
```
default <T extends CachedValues> com.aol.cyclops.sequence.Monoid<T> asReducer()
```
    Wrap multiple reducers or monoids into a single reducer instance, that can be used to reduce a given steam to multiple different values simultanously Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b); Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b); val result = tuple(sum,mult).<PTuple2<Integer,Integer>>asReducer() .mapReduce(Stream.of(1,2,3,4)); assertThat(result,equalTo(tuple(10,24))); Or alternatively Monoid<String> concat = Monoid.of("",(a,b)->a+b); Monoid<String> join = Monoid.of("",(a,b)->a+","+b); Monoid<CachedValues> reducer = PowerTuples.tuple(concat,join).asReducer(); assertThat(Stream.of("hello", "world", "woo!").map(CachedValues::of) .reduce(reducer.zero(),reducer.reducer()) ,equalTo(tuple("helloworldwoo!",",hello,world,woo!")));
    
    Returns:
  - asCollector
```
default <T,A,R> java.util.stream.Collector<T,A,R> asCollector()
```
    Wrap multiple collectors in a single Collector instance, so they can all run against a single Stream e.g PTuple2<Set<Integer>,List<Integer>> res = Stream.of(1, 2, 2) .collect(tuple(Collectors.toSet(),Collectors.toList()).asCollector()); Filters all non-Collector instances out of the Tuple
    
    Returns:
    
    Collector
  - compareTo
```
default int compareTo(CachedValues o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<CachedValues>
  - forEach
```
default void forEach(java.util.function.Consumer c)
```
    Specified by:
    
    forEach in interface java.lang.Iterable
  - filter
```
default <T extends CachedValues> T filter(java.util.function.Predicate<PTuple2<java.lang.Integer,java.lang.Object>> p)
```
  - toList
```
default <T> java.util.List<T> toList()
```
  - toMap
```
default <K,V> java.util.Map<K,V> toMap()
```
  - arity
```
int arity()
```
  - asFlattenedStream
```
default <T extends java.util.stream.Stream<?>> T asFlattenedStream()
```
    Will attempt to convert each element in the tuple into a flattened Stream
    
    Returns:
    
    Flattened Stream
  - asStreams
```
default <T extends java.util.stream.Stream<?>> java.util.stream.Stream<T> asStreams()
```
    Will attempt to convert each element in the tuple into a Stream Collection::stream CharSequence to stream File to Stream URL to Stream
    
    Returns:
    
    Stream of Streams
  - asStreamOfStrings
```
default java.util.stream.Stream<java.lang.String> asStreamOfStrings()
```
  - iterator
```
default java.util.Iterator iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable
    
    Specified by:
    
    iterator in interface com.aol.cyclops.sequence.streamable.ToStream
  - stream
```
default java.util.stream.Stream stream()
```
    Specified by:
    
    stream in interface com.aol.cyclops.sequence.streamable.ToStream
  - append
```
default <T extends CachedValues,X> T append(X value)
```
  - appendAll
```
default <T extends CachedValues> T appendAll(CachedValues values)
```
  - flatMap
```
default <T extends CachedValues,X extends CachedValues> T flatMap(java.util.function.Function<X,T> fn)
```
  - map
```
default <T extends CachedValues> T map(java.util.function.Function<java.util.List,java.util.List> fn)
```
  - of
```
static <T> CachedValues of(T value)
```
    Specified by:
    
    of in interface com.aol.cyclops.matcher.recursive.Matchable
  - of
```
static CachedValues of(java.lang.Object... values)
```

Interface CachedValues

Nested Class Summary

Method Summary

Methods inherited from interface com.aol.cyclops.matcher.recursive.Matchable

Methods inherited from interface com.aol.cyclops.objects.Decomposable

Methods inherited from interface com.aol.cyclops.sequence.streamable.ToStream

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops.comprehensions.donotation.Doable

Method Detail

getMatchable

getCachedValues

withArity

convert

to

asReducer

asCollector

compareTo

forEach

filter

toList

toMap

arity

asFlattenedStream

asStreams

asStreamOfStrings

iterator

stream

append

appendAll

flatMap

map

of

of