imemo10<A, B, C, D, E, F, G, H, I, J, R> function

Func10<A, B, C, D, E, F, G, H, I, J, R> imemo10<A, B, C, D, E, F, G, H, I, J, R>(Func10<A, B, C, D, E, F, G, H, I, J, R> func)

Checks 10 arguments for equality with identical call and returns cached result if they were not changed.

Implementation

Func10<A, B, C, D, E, F, G, H, I, J, R>
    imemo10<A, B, C, D, E, F, G, H, I, J, R>(
        Func10<A, B, C, D, E, F, G, H, I, J, R> func) {
  late A prevArgA;
  late B prevArgB;
  late C prevArgC;
  late D prevArgD;
  late E prevArgE;
  late F prevArgF;
  late G prevArgG;
  late H prevArgH;
  late I prevArgI;
  late J prevArgJ;
  late R prevResult;
  bool isInitial = true;

  return ((A argA, B argB, C argC, D argD, E argE, F argF, G argG, H argH,
      I argI, J argJ) {
    if (!isInitial &&
        identical(argA, prevArgA) &&
        identical(argB, prevArgB) &&
        identical(argC, prevArgC) &&
        identical(argD, prevArgD) &&
        identical(argE, prevArgE) &&
        identical(argF, prevArgF) &&
        identical(argG, prevArgG) &&
        identical(argH, prevArgH) &&
        identical(argI, prevArgI) &&
        identical(argJ, prevArgJ)) {
      return prevResult;
    } else {
      prevArgA = argA;
      prevArgB = argB;
      prevArgC = argC;
      prevArgD = argD;
      prevArgE = argE;
      prevArgF = argF;
      prevArgG = argG;
      prevArgH = argH;
      prevArgI = argI;
      prevArgJ = argJ;
      prevResult =
          func(argA, argB, argC, argD, argE, argF, argG, argH, argI, argJ);
      isInitial = false;

      return prevResult;
    }
  });
}