Iterable (Javaslang 2.0.0-beta API)

Type Parameters:

T - Component type

All Superinterfaces:

Iterable<T>

All Known Subinterfaces:

Arbitrary<T>, Gen<T>, IndexedSeq<T>, Iterator<T>, LinearSeq<T>, List<T>, Map<K,V>, Match.MatchMonad<R>, Option<T>, Seq<T>, Set<T>, SortedMap<K,V>, SortedSet<T>, Stack<T>, Stream<T>, Traversable<T>, TraversableOnce<T>, Tree<T>, Try<T>, Value<T>

All Known Implementing Classes:

AbstractIterator, Array, CharSeq, Either.LeftProjection, Either.RightProjection, Failure, HashMap, HashSet, Lazy, List.Cons, List.Nil, Match.MatchMonad.Otherwise, Match.MatchMonad.When.Then, None, Queue, Some, Stream.Cons, Stream.Empty, Success, Tree.Empty, Tree.Node, TreeMap, TreeSet, Vector
```
public interface Iterable<T>
extends Iterable<T>
```
A rich extension of java.lang.Iterable and basis of all Value types, e.g. controls, collections et al.

Since:

2.0.0

Author:

Daniel Dietrich

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U> boolean`	`corresponds(Iterable<U> that, java.util.function.BiPredicate<T,U> predicate)` Tests whether every element of this iterable relates to the corresponding element of another iterable by satisfying a test predicate.
`default boolean`	`eq(Object o)` A smoothing replacement for `equals`.
`default boolean`	`exists(java.util.function.Predicate<? super T> predicate)` Checks, if an element exists such that the predicate holds.
`default boolean`	`forAll(java.util.function.Predicate<? super T> predicate)` Checks, if the given predicate holds for all elements.
`default void`	`forEach(java.util.function.Consumer<? super T> action)` Performs an action on each element.
`default Iterator<IndexedSeq<T>>`	`grouped(int size)` Groups this `Traversable` into fixed size blocks.
`Iterator<T>`	`iterator()` Returns a rich `javaslang.collection.Iterator`.
`default Iterator<IndexedSeq<T>>`	`sliding(int size)` Slides a window of a specific `size` and step size 1 over this `Iterable` by calling `sliding(int, int)`.
`default Iterator<IndexedSeq<T>>`	`sliding(int size, int step)` Slides a window of a specific `size` and `step` size over this `Iterable`.

Methods inherited from interface java.lang.Iterable
spliterator

- Method Detail
  - iterator
```
Iterator<T> iterator()
```
    Returns a rich javaslang.collection.Iterator.
    
    Specified by:
    
    iterator in interface Iterable<T>
    
    Returns:
    
    A new Iterator
  - corresponds
```
default <U> boolean corresponds(Iterable<U> that,
                                java.util.function.BiPredicate<T,U> predicate)
```
    Tests whether every element of this iterable relates to the corresponding element of another iterable by satisfying a test predicate.
    
    Type Parameters:
    
    U - Component type of that iterable
    
    Parameters:
    
    that - the other iterable
    
    predicate - the test predicate, which relates elements from both iterables
    
    Returns:
    
    true if both iterables have the same length and predicate(x, y) is true for all corresponding elements x of this iterable and y of that, otherwise false.
  - eq
```
default boolean eq(Object o)
```
    A smoothing replacement for equals. It is similar to Scala's == but better in the way that it is not limited to collection types, e.g. `Some(1) eq List(1)`, `None eq Failure(x)` etc.
    In a nutshell: eq checks congruence of structures and equality of contained values.
    Example:
```
 // ((1, 2), ((3))) => structure: (()(())) values: 1, 2, 3
 final Iterable<?> i1 = List.of(List.of(1, 2), Arrays.asList(List.of(3)));
 final Iterable<?> i2 = Queue.of(Stream.of(1, 2), List.of(Lazy.of(() -> 3)));
 assertThat(i1.eq(i2)).isTrue();
 
```
    Semantics:
```
 o == this                       : true
 o instanceof javaslang.Iterable : iterable elements are eq, non-iterable elements equals, for all (o1, o2) in (this, o)
 o instanceof java.lang.Iterable : this eq Iterator.ofAll((java.lang.Iterable<?>) o);
 otherwise                       : false
 
```
    Parameters:
    
    o - An object
    
    Returns:
    
    true, if this equals o according to the rules defined above, otherwise false.
  - exists
```
default boolean exists(java.util.function.Predicate<? super T> predicate)
```
    Checks, if an element exists such that the predicate holds.
    
    Parameters:
    
    predicate - A Predicate
    
    Returns:
    
    true, if predicate holds for one or more elements, false otherwise
    
    Throws:
    
    NullPointerException - if predicate is null
  - forAll
```
default boolean forAll(java.util.function.Predicate<? super T> predicate)
```
    Checks, if the given predicate holds for all elements.
    
    Parameters:
    
    predicate - A Predicate
    
    Returns:
    
    true, if the predicate holds for all elements, false otherwise
    
    Throws:
    
    NullPointerException - if predicate is null
  - forEach
```
default void forEach(java.util.function.Consumer<? super T> action)
```
    Performs an action on each element.
    
    Specified by:
    
    forEach in interface Iterable<T>
    
    Parameters:
    
    action - A Consumer
    
    Throws:
    
    NullPointerException - if action is null
  - grouped
```
default Iterator<IndexedSeq<T>> grouped(int size)
```
    Groups this Traversable into fixed size blocks.
    Let length be the length of this Iterable. Then grouped is defined as follows:
    - If this.isEmpty(), the resulting Iterator is empty.
    - If size <= length, the resulting Iterator will contain length / size blocks of size size and maybe a non-empty block of size length % size, if there are remaining elements.
    - If size > length, the resulting Iterator will contain one block of size length.
    Examples:
```
 
 [].grouped(1) = []
 [].grouped(0) throws
 [].grouped(-1) throws
 [1,2,3,4].grouped(2) = [[1,2],[3,4]]
 [1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
 [1,2,3,4].grouped(5) = [[1,2,3,4]]
 
 
```
    Please note that grouped(int) is a special case of sliding(int, int), i.e. grouped(size) is the same as sliding(size, size).
    Parameters:
    
    size - a positive block size
    
    Returns:
    
    A new Iterator of grouped blocks of the given size
    
    Throws:
    
    IllegalArgumentException - if size is negative or zero
  - sliding
```
default Iterator<IndexedSeq<T>> sliding(int size)
```
    Slides a window of a specific size and step size 1 over this Iterable by calling sliding(int, int).
    
    Parameters:
    
    size - a positive window size
    
    Returns:
    
    a new Iterator of windows of a specific size using step size 1
    
    Throws:
    
    IllegalArgumentException - if size is negative or zero
  - sliding
```
default Iterator<IndexedSeq<T>> sliding(int size,
                                        int step)
```
    Slides a window of a specific size and step size over this Iterable.
    Examples:
```
 
 [].sliding(1,1) = []
 [1,2,3,4,5].sliding(2,3) = [[1,2],[4,5]]
 [1,2,3,4,5].sliding(2,4) = [[1,2],[5]]
 [1,2,3,4,5].sliding(2,5) = [[1,2]]
 [1,2,3,4].sliding(5,3) = [[1,2,3,4],[4]]
 
 
```
    Parameters:
    
    size - a positive window size
    
    step - a positive step size
    
    Returns:
    
    a new Iterator of windows of a specific size using a specific step size
    
    Throws:
    
    IllegalArgumentException - if size or step are negative or zero

Interface Iterable<T>

Method Summary

Methods inherited from interface java.lang.Iterable

Method Detail

iterator

corresponds

eq

exists

forAll

forEach

grouped

sliding

sliding