createSelector10<S, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, T> function

Selector<S, T> createSelector10<S, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, T>(
  1. Selector<S, R1> selector1,
  2. Selector<S, R2> selector2,
  3. Selector<S, R3> selector3,
  4. Selector<S, R4> selector4,
  5. Selector<S, R5> selector5,
  6. Selector<S, R6> selector6,
  7. Selector<S, R7> selector7,
  8. Selector<S, R8> selector8,
  9. Selector<S, R9> selector9,
  10. Selector<S, R10> selector10,
  11. T combiner(
    1. R1,
    2. R2,
    3. R3,
    4. R4,
    5. R5,
    6. R6,
    7. R7,
    8. R8,
    9. R9,
    10. R10
    ),
  12. {T Function(R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) memoize(
    1. T (
      1. R1,
      2. R2,
      3. R3,
      4. R4,
      5. R5,
      6. R6,
      7. R7,
      8. R8,
      9. R9,
      10. R10
      )
    )?}
)

Create a memoized selector by combining ten selectors. It will cache the result of the combiner function, and only recompute when the provided selectors deliver new results.

A complete example can be seen as part of the Selector documentation.

Implementation

Selector<S, T> createSelector10<S, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, T>(
  Selector<S, R1> selector1,
  Selector<S, R2> selector2,
  Selector<S, R3> selector3,
  Selector<S, R4> selector4,
  Selector<S, R5> selector5,
  Selector<S, R6> selector6,
  Selector<S, R7> selector7,
  Selector<S, R8> selector8,
  Selector<S, R9> selector9,
  Selector<S, R10> selector10,
  T Function(R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) combiner, {
  T Function(R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) Function(
          T Function(R1, R2, R3, R4, R5, R6, R7, R8, R9, R10))?
      memoize,
}) {
  final memoized = (memoize ?? memo10)(combiner);

  return (S state) {
    return memoized(
      selector1(state),
      selector2(state),
      selector3(state),
      selector4(state),
      selector5(state),
      selector6(state),
      selector7(state),
      selector8(state),
      selector9(state),
      selector10(state),
    );
  };
}