org.apache.tapestry5.func

## Interface ZippedFlow<A,B>

- Type Parameters:
    `A` -
    `B` -
  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 and 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).

${project.version} - Copyright © 2003-2015 The Apache Software Foundation.