EmeticStream (io.earcam.unexceptional 1.0.0 API)

Type Parameters:

T - the element type of this stream

All Superinterfaces:

AutoCloseable

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
```
@FunctionalInterface
public interface EmeticStream<T>
extends AutoCloseable
```
EmeticStream provides a functional parallel to Stream, with methods taking checked equivalents of java.util.function

emetic
/ɪˈmɛtɪk/
adjective:

1. (of a substance) causing vomiting.

Since:

0.2.0

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`allMatch(CheckedPredicate<? super T,?> predicate)`
`default boolean`	`anyMatch(CheckedPredicate<? super T,?> predicate)`
`default void`	`close()` Closes the wrapped stream, invoking all registered close handlers.
`default <R> R`	`collect(CheckedSupplier<R,?> supplier, CheckedBiConsumer<R,? super T,?> accumulator, CheckedBiConsumer<R,R,?> combiner)`
`default <R,A> R`	`collect(Collector<? super T,A,R> collector)`
`default long`	`count()`
`static <T,R> EmeticStream<R>`	`emesis(CheckedFunction<T,Stream<R>,?> function, T value)`
`static <T> EmeticStream<T>`	`emesis(Stream<T> stream)` Wrap a stream in order to invoke check functions on it
`default EmeticStream<T>`	`filter(CheckedPredicate<? super T,?> predicate)`
`default <R> EmeticStream<R>`	`flatMap(CheckedFunction<? super T,? extends Stream<? extends R>,?> mapper)`
`default DoubleStream`	`flatMapToDouble(CheckedFunction<? super T,? extends DoubleStream,?> mapper)`
`default IntStream`	`flatMapToInt(CheckedFunction<? super T,? extends IntStream,?> mapper)`
`default LongStream`	`flatMapToLong(CheckedFunction<? super T,? extends LongStream,?> mapper)`
`default void`	`forEach(CheckedConsumer<? super T,?> action)`
`default void`	`forEachOrdered(CheckedConsumer<? super T,?> action)`
`default boolean`	`isParallel()` Returns whether the wrapped stream would execute in parallel, if a terminal operation were executed.
`default Iterator<T>`	`iterator()` Returns an iterator for the elements of the wrapped stream.
`default <R> EmeticStream<R>`	`map(CheckedFunction<? super T,? extends R,?> mapper)`
`default DoubleStream`	`mapToDouble(CheckedToDoubleFunction<? super T,?> mapper)`
`default IntStream`	`mapToInt(CheckedToIntFunction<? super T,?> mapper)`
`default LongStream`	`mapToLong(CheckedToLongFunction<? super T,?> mapper)`
`Stream<T>`	`mapToStream()`
`default Optional<T>`	`max(CheckedComparator<? super T,?> comparator)`
`default Optional<T>`	`min(CheckedComparator<? super T,?> comparator)`
`default boolean`	`noneMatch(CheckedPredicate<? super T,?> predicate)`
`default EmeticStream<T>`	`onClose(Runnable closeHandler)` Returns an equivalent stream with the additional close handler.
`default EmeticStream<T>`	`parallel()`
`default EmeticStream<T>`	`peek(CheckedConsumer<? super T,?> action)`
`default Optional<T>`	`reduce(CheckedBinaryOperator<T,?> accumulator)`
`default T`	`reduce(T identity, CheckedBinaryOperator<T,?> accumulator)`
`default EmeticStream<T>`	`sequential()`
`default EmeticStream<T>`	`sorted(CheckedComparator<? super T,?> comparator)`
`default Spliterator<T>`	`spliterator()` Returns a spliterator for the elements of the wrapped stream.
`default EmeticStream<T>`	`unordered()` Returns an equivalent stream that is unordered.

- Method Detail
  - mapToStream
```
Stream<T> mapToStream()
```
    Returns:
    
    the wrapped stream
  - emesis
```
static <T,R> EmeticStream<R> emesis(CheckedFunction<T,Stream<R>,?> function,
                                    T value)
```
    Type Parameters:
    
    T - the function's argument type
    
    R - the element type of this stream
    
    Parameters:
    
    function - the checked function which, when applied to the value produces the Stream to be returned
    
    value - argument for the function
    
    Returns:
    
    the Stream result of applying function to value
    
    Since:
    
    0.2.0
  - emesis
```
static <T> EmeticStream<T> emesis(Stream<T> stream)
```
    Wrap a stream in order to invoke check functions on it
    
    Type Parameters:
    
    T - the stream's element type
    
    Parameters:
    
    stream - the underlying Stream
    
    Returns:
    
    an EmeticStream
    
    Since:
    
    0.2.0
  - parallel
```
default EmeticStream<T> parallel()
```
    Returns:
    
    a parallel emetic stream
    
    Since:
    
    0.2.0
    
    See Also:
    
    BaseStream.parallel()
  - sequential
```
default EmeticStream<T> sequential()
```
    Returns:
    
    a sequential emetic stream
    
    Since:
    
    0.2.0
    
    See Also:
    
    BaseStream.sequential()
  - unordered
```
default EmeticStream<T> unordered()
```
    Returns an equivalent stream that is unordered.
    
    Returns:
    
    an unordered emetic stream
    
    Since:
    
    0.5.0
    
    See Also:
    
    BaseStream.unordered()
  - iterator
```
default Iterator<T> iterator()
```
    Returns an iterator for the elements of the wrapped stream.
    
    Returns:
    
    the element iterator for the wrapped stream
    
    Since:
    
    0.5.0
    
    See Also:
    
    BaseStream.iterator()
  - spliterator
```
default Spliterator<T> spliterator()
```
    Returns a spliterator for the elements of the wrapped stream.
    
    Returns:
    
    the element spliterator for this stream
    
    Since:
    
    0.5.0
    
    See Also:
    
    BaseStream.spliterator()
  - isParallel
```
default boolean isParallel()
```
    Returns whether the wrapped stream would execute in parallel, if a terminal operation were executed.
    
    Returns:
    
    true if the wrapped stream would execute in parallel
    
    Since:
    
    0.5.0
    
    See Also:
    
    BaseStream.isParallel()
  - allMatch
```
default boolean allMatch(CheckedPredicate<? super T,?> predicate)
```
    Parameters:
    
    predicate - a non-interfering and stateless, checked predicate 𝗣 to apply to all elements in the stream 𝕊
    
    Returns:
    
    ∀ e ∈ 𝕊: 𝗣(e)
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.allMatch(java.util.function.Predicate)
  - anyMatch
```
default boolean anyMatch(CheckedPredicate<? super T,?> predicate)
```
    Parameters:
    
    predicate - a non-interfering and stateless, checked predicate 𝗣 to apply to all elements in the stream 𝕊
    
    Returns:
    
    ∃ e ∈ 𝕊: 𝗣(e)
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.anyMatch(java.util.function.Predicate)
  - collect
```
default <R,A> R collect(Collector<? super T,A,R> collector)
```
    Type Parameters:
    
    A - mutable accumulator type
    
    R - reduction result type
    
    Parameters:
    
    collector - Collector performing reduction and supplying result
    
    Returns:
    
    the result
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.collect(Collector)
  - collect
```
default <R> R collect(CheckedSupplier<R,?> supplier,
                      CheckedBiConsumer<R,? super T,?> accumulator,
                      CheckedBiConsumer<R,R,?> combiner)
```
    Type Parameters:
    
    R - result type
    
    Parameters:
    
    supplier - creates a new (potentially partial) result container
    
    accumulator - associative, non-interfering, stateless function, adding element to result
    
    combiner - combines the accumulated results
    
    Returns:
    
    the collected result
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.collect(java.util.function.Supplier, java.util.function.BiConsumer, java.util.function.BiConsumer)
  - filter
```
default EmeticStream<T> filter(CheckedPredicate<? super T,?> predicate)
```
    Parameters:
    
    predicate - a non-interfering, stateless predicate determining which elements travel downStream
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.filter(java.util.function.Predicate)
  - flatMap
```
default <R> EmeticStream<R> flatMap(CheckedFunction<? super T,? extends Stream<? extends R>,?> mapper)
```
    Type Parameters:
    
    R - element type of the new stream
    
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to Stream<R>
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.flatMap(java.util.function.Function)
  - flatMapToDouble
```
default DoubleStream flatMapToDouble(CheckedFunction<? super T,? extends DoubleStream,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to DoubleStream
    
    Returns:
    
    the new DoubleStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.flatMapToDouble(java.util.function.Function)
  - flatMapToInt
```
default IntStream flatMapToInt(CheckedFunction<? super T,? extends IntStream,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to IntStream
    
    Returns:
    
    the new IntStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.flatMapToInt(java.util.function.Function)
  - flatMapToLong
```
default LongStream flatMapToLong(CheckedFunction<? super T,? extends LongStream,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to LongStream
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.flatMapToLong(java.util.function.Function)
  - forEach
```
default void forEach(CheckedConsumer<? super T,?> action)
```
    Parameters:
    
    action - a non-interfering action to apply to each element
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.forEach(java.util.function.Consumer)
  - forEachOrdered
```
default void forEachOrdered(CheckedConsumer<? super T,?> action)
```
    Parameters:
    
    action - a non-interfering action to apply to each element
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.forEachOrdered(java.util.function.Consumer)
  - map
```
default <R> EmeticStream<R> map(CheckedFunction<? super T,? extends R,?> mapper)
```
    Type Parameters:
    
    R - the element type of returned Stream
    
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to <R>
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.map(java.util.function.Function)
  - mapToDouble
```
default DoubleStream mapToDouble(CheckedToDoubleFunction<? super T,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to double
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.mapToDouble(java.util.function.ToDoubleFunction)
  - mapToInt
```
default IntStream mapToInt(CheckedToIntFunction<? super T,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to int
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.mapToInt(java.util.function.ToIntFunction)
  - mapToLong
```
default LongStream mapToLong(CheckedToLongFunction<? super T,?> mapper)
```
    Parameters:
    
    mapper - a non-interfering, stateless function transforming <T> to long
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.mapToLong(java.util.function.ToLongFunction)
  - max
```
default Optional<T> max(CheckedComparator<? super T,?> comparator)
```
    Parameters:
    
    comparator - a non-interfering, stateless comparator
    
    Returns:
    
    an Optional as per Stream.max(java.util.Comparator)
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.max(java.util.Comparator)
  - min
```
default Optional<T> min(CheckedComparator<? super T,?> comparator)
```
    Parameters:
    
    comparator - a non-interfering, stateless comparator
    
    Returns:
    
    an Optional as per Stream.max(java.util.Comparator)
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.min(java.util.Comparator)
  - noneMatch
```
default boolean noneMatch(CheckedPredicate<? super T,?> predicate)
```
    Parameters:
    
    predicate - a non-interfering, stateless, checked predicate 𝗣 to apply to all elements in the stream 𝕊
    
    Returns:
    
    ∄ e ∈ 𝕊: 𝗣(e)
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.noneMatch(java.util.function.Predicate)
  - peek
```
default EmeticStream<T> peek(CheckedConsumer<? super T,?> action)
```
    Parameters:
    
    action - non-interfering action applied to elements of the underlying Stream
    
    Returns:
    
    the new EmeticStream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.peek(java.util.function.Consumer)
  - reduce
```
default Optional<T> reduce(CheckedBinaryOperator<T,?> accumulator)
```
    Parameters:
    
    accumulator - an associative, non-interfering and stateless function
    
    Returns:
    
    the reduction
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.reduce(java.util.function.BinaryOperator)
  - reduce
```
default T reduce(T identity,
                 CheckedBinaryOperator<T,?> accumulator)
```
    Parameters:
    
    identity - seed value for accumulator
    
    accumulator - an associative, non-interfering and stateless function
    
    Returns:
    
    the reduction
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.reduce(Object, java.util.function.BinaryOperator)
  - sorted
```
default EmeticStream<T> sorted(CheckedComparator<? super T,?> comparator)
```
    Parameters:
    
    comparator - non-interfering, stateless comparator to sort
    
    Returns:
    
    an emetic stream wrapping the underlying sorted stream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.sorted(java.util.Comparator)
  - count
```
default long count()
```
    Returns:
    
    count of elements in this stream
    
    Since:
    
    0.2.0
    
    See Also:
    
    Stream.count()
  - onClose
```
default EmeticStream<T> onClose(Runnable closeHandler)
```
    Returns an equivalent stream with the additional close handler.
    
    Parameters:
    
    closeHandler - A runnable executed when the stream is closed
    
    Returns:
    
    a stream with a handler registered
    
    Since:
    
    0.5.0
    
    See Also:
    
    BaseStream.onClose(Runnable)
  - close
```
default void close()
```
    Closes the wrapped stream, invoking all registered close handlers.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Since:
    
    0.5.0
    
    See Also:
    
    AutoCloseable.close(), BaseStream.unordered()

Interface EmeticStream<T>

emetic

Method Summary

Method Detail

mapToStream

emesis

emesis

parallel

sequential

unordered

iterator

spliterator

isParallel

allMatch

anyMatch

collect

collect

filter

flatMap

flatMapToDouble

flatMapToInt

flatMapToLong

forEach

forEachOrdered

map

mapToDouble

mapToInt

mapToLong

max

min

noneMatch

peek

reduce

reduce

sorted

count

onClose

close