Package org.apache.tapestry5.func

## Interface ZippedFlow<A,​B>

- Type Parameters:
    `A` - first type
    `B` - second type
  All Superinterfaces:
    `FlowOperations<Tuple<A,​B>,​ZippedFlow<A,​B>>`, `Iterable<Tuple<A,​B>>`

      public interface ZippedFlow<A,​B>
      extends FlowOperations<Tuple<A,​B>,​ZippedFlow<A,​B>>

  The result of the `Flow.zipWith(Flow)` method (or created from a Map via `F.zippedFlow(Map)`), a Flow of combined `Tuple` values (that can be deconstructed, eventually, using `unzip()`).
  Since:
    5.3

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `ZippedFlow<A,​B>` | `filterOnFirst​(Predicate<? super A> predicate)` | Filters the tuples in the zipped flow by applying a predicate to the first value in each tuple.
    `ZippedFlow<A,​B>` | `filterOnSecond​(Predicate<? super B> predicate)` | Filters the tuples in the zipped flow by applying a predicate to the second value in each tuple.
    `Flow<A>` | `firsts()` | Returns a flow of the first values of the tuples of the zipped flow.
    `<X,​Y> ZippedFlow<X,​Y>` | `mapTuples​(Mapper<Tuple<A,​B>,​Tuple<X,​Y>> mapper)` | Mapping for zipped flows; a mapper is used to map tuples of this zipped flow into new tuples with a new type, forming the resulting zipped flow.
    `ZippedFlow<A,​B>` | `removeOnFirst​(Predicate<? super A> predicate)` | Removes tuples from the zipped flow by applying a predicate to the first value in each tuple.
    `ZippedFlow<A,​B>` | `removeOnSecond​(Predicate<? super B> predicate)` | Removes tuples from the zipped flow by applying a predicate to the second value in each tuple.
    `Flow<B>` | `seconds()` | Returns a flow of the second values of the tuples of the zipped flow.
    `Map<A,​B>` | `toMap()` | Constructs a HashMap by converting the tuples of the zipped flow into keys (first tuple value) and values (second tuple value).
    `Tuple<Flow<A>,​Flow<B>>` | `unzip()` | A ZippedFlow is a Flow of Tuples; this inverts that, splitting each Tuple into a Flow of elements, then assembling the result as a Tuple of two values.

    - ### Methods inherited from interface org.apache.tapestry5.func.FlowOperations

      `concat, count, drop, each, filter, first, isEmpty, reduce, remove, removeNulls, rest, reverse, sort, take, toList, toSet`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach, iterator, spliterator`

- - ### Method Detail

    - #### mapTuples

          <X,​Y> ZippedFlow<X,​Y> mapTuples​(Mapper<Tuple<A,​B>,​Tuple<X,​Y>> mapper)

      Mapping for zipped flows; a mapper is used to map tuples of this zipped flow into new tuples with a new type, forming the resulting zipped flow. This is a lazy operation.

    - #### unzip

          Tuple<Flow<A>,​Flow<B>> unzip()

      A ZippedFlow is a Flow of Tuples; this inverts that, splitting each Tuple into a Flow of elements, then assembling the result as a Tuple of two values. This is a lazy operation.
      Returns:
        two flows of unzipped Tuples

    - #### firsts

          Flow<A> firsts()

      Returns a flow of the first values of the tuples of the zipped flow. This is a lazy operation.

    - #### seconds

          Flow<B> seconds()

      Returns a flow of the second values of the tuples of the zipped flow. This is a lazy operation.

    - #### filterOnFirst

          ZippedFlow<A,​B> filterOnFirst​(Predicate<? super A> predicate)

      Filters the tuples in the zipped flow by applying a predicate to the first value in each tuple. This is a lazy operation.

    - #### filterOnSecond

          ZippedFlow<A,​B> filterOnSecond​(Predicate<? super B> predicate)

      Filters the tuples in the zipped flow by applying a predicate to the second value in each tuple. This is a lazy operations.

    - #### removeOnFirst

          ZippedFlow<A,​B> removeOnFirst​(Predicate<? super A> predicate)

      Removes tuples from the zipped flow by applying a predicate to the first value in each tuple. This is a lazy operation.

    - #### removeOnSecond

          ZippedFlow<A,​B> removeOnSecond​(Predicate<? super B> predicate)

      Removes tuples from the zipped flow by applying a predicate to the second value in each tuple. This is a lazy operations.

    - #### toMap

          Map<A,​B> toMap()

      Constructs a HashMap by converting the tuples of the zipped flow into keys (first tuple value) and values (second tuple value).