core/japgolly.scalagraal.util/StrFnCacheParamBoilerplate

StrFnCacheParamBoilerplate

abstract class StrFnCacheParamBoilerplate
class Object
trait Matchable
class Any

Value members

Abstract methods

def apply[A](paths: List[StrFnCachePath[A]]): StrFnCacheParam[A]

Concrete methods

final def apply10[A, B, C, D, E, F, G, H, I, J, Z](f: (A, B, C, D, E, F, G, H, I, J) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J)]): StrFnCacheParam[Z]
final def apply11[A, B, C, D, E, F, G, H, I, J, K, Z](f: (A, B, C, D, E, F, G, H, I, J, K) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K)]): StrFnCacheParam[Z]
final def apply12[A, B, C, D, E, F, G, H, I, J, K, L, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L)]): StrFnCacheParam[Z]
final def apply13[A, B, C, D, E, F, G, H, I, J, K, L, M, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M)]): StrFnCacheParam[Z]
final def apply14[A, B, C, D, E, F, G, H, I, J, K, L, M, N, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]): StrFnCacheParam[Z]
final def apply15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]): StrFnCacheParam[Z]
final def apply16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]): StrFnCacheParam[Z]
final def apply17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]): StrFnCacheParam[Z]
final def apply18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]): StrFnCacheParam[Z]
final def apply19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]): StrFnCacheParam[Z]
final def apply2[A, B, Z](f: (A, B) => Z)(g: Z => (A, B))(implicit t: StrFnCacheParam[(A, B)]): StrFnCacheParam[Z]
final def apply20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]): StrFnCacheParam[Z]
final def apply21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]): StrFnCacheParam[Z]
final def apply22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Z](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => Z)(g: Z => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]): StrFnCacheParam[Z]
final def apply3[A, B, C, Z](f: (A, B, C) => Z)(g: Z => (A, B, C))(implicit t: StrFnCacheParam[(A, B, C)]): StrFnCacheParam[Z]
final def apply4[A, B, C, D, Z](f: (A, B, C, D) => Z)(g: Z => (A, B, C, D))(implicit t: StrFnCacheParam[(A, B, C, D)]): StrFnCacheParam[Z]
final def apply5[A, B, C, D, E, Z](f: (A, B, C, D, E) => Z)(g: Z => (A, B, C, D, E))(implicit t: StrFnCacheParam[(A, B, C, D, E)]): StrFnCacheParam[Z]
final def apply6[A, B, C, D, E, F, Z](f: (A, B, C, D, E, F) => Z)(g: Z => (A, B, C, D, E, F))(implicit t: StrFnCacheParam[(A, B, C, D, E, F)]): StrFnCacheParam[Z]
final def apply7[A, B, C, D, E, F, G, Z](f: (A, B, C, D, E, F, G) => Z)(g: Z => (A, B, C, D, E, F, G))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G)]): StrFnCacheParam[Z]
final def apply8[A, B, C, D, E, F, G, H, Z](f: (A, B, C, D, E, F, G, H) => Z)(g: Z => (A, B, C, D, E, F, G, H))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H)]): StrFnCacheParam[Z]
final def apply9[A, B, C, D, E, F, G, H, I, Z](f: (A, B, C, D, E, F, G, H, I) => Z)(g: Z => (A, B, C, D, E, F, G, H, I))(implicit t: StrFnCacheParam[(A, B, C, D, E, F, G, H, I)]): StrFnCacheParam[Z]
final def divide10[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J])(implicit evidence$45: ClassTag[A], evidence$46: ClassTag[B], evidence$47: ClassTag[C], evidence$48: ClassTag[D], evidence$49: ClassTag[E], evidence$50: ClassTag[F], evidence$51: ClassTag[G], evidence$52: ClassTag[H], evidence$53: ClassTag[I], evidence$54: ClassTag[J]): StrFnCacheParam[Z]
final def divide11[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K])(implicit evidence$55: ClassTag[A], evidence$56: ClassTag[B], evidence$57: ClassTag[C], evidence$58: ClassTag[D], evidence$59: ClassTag[E], evidence$60: ClassTag[F], evidence$61: ClassTag[G], evidence$62: ClassTag[H], evidence$63: ClassTag[I], evidence$64: ClassTag[J], evidence$65: ClassTag[K]): StrFnCacheParam[Z]
final def divide12[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L])(implicit evidence$66: ClassTag[A], evidence$67: ClassTag[B], evidence$68: ClassTag[C], evidence$69: ClassTag[D], evidence$70: ClassTag[E], evidence$71: ClassTag[F], evidence$72: ClassTag[G], evidence$73: ClassTag[H], evidence$74: ClassTag[I], evidence$75: ClassTag[J], evidence$76: ClassTag[K], evidence$77: ClassTag[L]): StrFnCacheParam[Z]
final def divide13[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M])(implicit evidence$78: ClassTag[A], evidence$79: ClassTag[B], evidence$80: ClassTag[C], evidence$81: ClassTag[D], evidence$82: ClassTag[E], evidence$83: ClassTag[F], evidence$84: ClassTag[G], evidence$85: ClassTag[H], evidence$86: ClassTag[I], evidence$87: ClassTag[J], evidence$88: ClassTag[K], evidence$89: ClassTag[L], evidence$90: ClassTag[M]): StrFnCacheParam[Z]
final def divide14[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N])(implicit evidence$91: ClassTag[A], evidence$92: ClassTag[B], evidence$93: ClassTag[C], evidence$94: ClassTag[D], evidence$95: ClassTag[E], evidence$96: ClassTag[F], evidence$97: ClassTag[G], evidence$98: ClassTag[H], evidence$99: ClassTag[I], evidence$100: ClassTag[J], evidence$101: ClassTag[K], evidence$102: ClassTag[L], evidence$103: ClassTag[M], evidence$104: ClassTag[N]): StrFnCacheParam[Z]
final def divide15[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O])(implicit evidence$105: ClassTag[A], evidence$106: ClassTag[B], evidence$107: ClassTag[C], evidence$108: ClassTag[D], evidence$109: ClassTag[E], evidence$110: ClassTag[F], evidence$111: ClassTag[G], evidence$112: ClassTag[H], evidence$113: ClassTag[I], evidence$114: ClassTag[J], evidence$115: ClassTag[K], evidence$116: ClassTag[L], evidence$117: ClassTag[M], evidence$118: ClassTag[N], evidence$119: ClassTag[O]): StrFnCacheParam[Z]
final def divide16[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P])(implicit evidence$120: ClassTag[A], evidence$121: ClassTag[B], evidence$122: ClassTag[C], evidence$123: ClassTag[D], evidence$124: ClassTag[E], evidence$125: ClassTag[F], evidence$126: ClassTag[G], evidence$127: ClassTag[H], evidence$128: ClassTag[I], evidence$129: ClassTag[J], evidence$130: ClassTag[K], evidence$131: ClassTag[L], evidence$132: ClassTag[M], evidence$133: ClassTag[N], evidence$134: ClassTag[O], evidence$135: ClassTag[P]): StrFnCacheParam[Z]
final def divide17[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q])(implicit evidence$136: ClassTag[A], evidence$137: ClassTag[B], evidence$138: ClassTag[C], evidence$139: ClassTag[D], evidence$140: ClassTag[E], evidence$141: ClassTag[F], evidence$142: ClassTag[G], evidence$143: ClassTag[H], evidence$144: ClassTag[I], evidence$145: ClassTag[J], evidence$146: ClassTag[K], evidence$147: ClassTag[L], evidence$148: ClassTag[M], evidence$149: ClassTag[N], evidence$150: ClassTag[O], evidence$151: ClassTag[P], evidence$152: ClassTag[Q]): StrFnCacheParam[Z]
final def divide18[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, R <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R])(implicit evidence$153: ClassTag[A], evidence$154: ClassTag[B], evidence$155: ClassTag[C], evidence$156: ClassTag[D], evidence$157: ClassTag[E], evidence$158: ClassTag[F], evidence$159: ClassTag[G], evidence$160: ClassTag[H], evidence$161: ClassTag[I], evidence$162: ClassTag[J], evidence$163: ClassTag[K], evidence$164: ClassTag[L], evidence$165: ClassTag[M], evidence$166: ClassTag[N], evidence$167: ClassTag[O], evidence$168: ClassTag[P], evidence$169: ClassTag[Q], evidence$170: ClassTag[R]): StrFnCacheParam[Z]
final def divide19[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, R <: Z, S <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S])(implicit evidence$171: ClassTag[A], evidence$172: ClassTag[B], evidence$173: ClassTag[C], evidence$174: ClassTag[D], evidence$175: ClassTag[E], evidence$176: ClassTag[F], evidence$177: ClassTag[G], evidence$178: ClassTag[H], evidence$179: ClassTag[I], evidence$180: ClassTag[J], evidence$181: ClassTag[K], evidence$182: ClassTag[L], evidence$183: ClassTag[M], evidence$184: ClassTag[N], evidence$185: ClassTag[O], evidence$186: ClassTag[P], evidence$187: ClassTag[Q], evidence$188: ClassTag[R], evidence$189: ClassTag[S]): StrFnCacheParam[Z]
final def divide2[A <: Z, B <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B])(implicit evidence$1: ClassTag[A], evidence$2: ClassTag[B]): StrFnCacheParam[Z]
final def divide20[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, R <: Z, S <: Z, T <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T])(implicit evidence$190: ClassTag[A], evidence$191: ClassTag[B], evidence$192: ClassTag[C], evidence$193: ClassTag[D], evidence$194: ClassTag[E], evidence$195: ClassTag[F], evidence$196: ClassTag[G], evidence$197: ClassTag[H], evidence$198: ClassTag[I], evidence$199: ClassTag[J], evidence$200: ClassTag[K], evidence$201: ClassTag[L], evidence$202: ClassTag[M], evidence$203: ClassTag[N], evidence$204: ClassTag[O], evidence$205: ClassTag[P], evidence$206: ClassTag[Q], evidence$207: ClassTag[R], evidence$208: ClassTag[S], evidence$209: ClassTag[T]): StrFnCacheParam[Z]
final def divide21[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, R <: Z, S <: Z, T <: Z, U <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T], cU: StrFnCacheParam[U])(implicit evidence$210: ClassTag[A], evidence$211: ClassTag[B], evidence$212: ClassTag[C], evidence$213: ClassTag[D], evidence$214: ClassTag[E], evidence$215: ClassTag[F], evidence$216: ClassTag[G], evidence$217: ClassTag[H], evidence$218: ClassTag[I], evidence$219: ClassTag[J], evidence$220: ClassTag[K], evidence$221: ClassTag[L], evidence$222: ClassTag[M], evidence$223: ClassTag[N], evidence$224: ClassTag[O], evidence$225: ClassTag[P], evidence$226: ClassTag[Q], evidence$227: ClassTag[R], evidence$228: ClassTag[S], evidence$229: ClassTag[T], evidence$230: ClassTag[U]): StrFnCacheParam[Z]
final def divide22[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, J <: Z, K <: Z, L <: Z, M <: Z, N <: Z, O <: Z, P <: Z, Q <: Z, R <: Z, S <: Z, T <: Z, U <: Z, V <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T], cU: StrFnCacheParam[U], cV: StrFnCacheParam[V])(implicit evidence$231: ClassTag[A], evidence$232: ClassTag[B], evidence$233: ClassTag[C], evidence$234: ClassTag[D], evidence$235: ClassTag[E], evidence$236: ClassTag[F], evidence$237: ClassTag[G], evidence$238: ClassTag[H], evidence$239: ClassTag[I], evidence$240: ClassTag[J], evidence$241: ClassTag[K], evidence$242: ClassTag[L], evidence$243: ClassTag[M], evidence$244: ClassTag[N], evidence$245: ClassTag[O], evidence$246: ClassTag[P], evidence$247: ClassTag[Q], evidence$248: ClassTag[R], evidence$249: ClassTag[S], evidence$250: ClassTag[T], evidence$251: ClassTag[U], evidence$252: ClassTag[V]): StrFnCacheParam[Z]
final def divide3[A <: Z, B <: Z, C <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C])(implicit evidence$3: ClassTag[A], evidence$4: ClassTag[B], evidence$5: ClassTag[C]): StrFnCacheParam[Z]
final def divide4[A <: Z, B <: Z, C <: Z, D <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D])(implicit evidence$6: ClassTag[A], evidence$7: ClassTag[B], evidence$8: ClassTag[C], evidence$9: ClassTag[D]): StrFnCacheParam[Z]
final def divide5[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E])(implicit evidence$10: ClassTag[A], evidence$11: ClassTag[B], evidence$12: ClassTag[C], evidence$13: ClassTag[D], evidence$14: ClassTag[E]): StrFnCacheParam[Z]
final def divide6[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F])(implicit evidence$15: ClassTag[A], evidence$16: ClassTag[B], evidence$17: ClassTag[C], evidence$18: ClassTag[D], evidence$19: ClassTag[E], evidence$20: ClassTag[F]): StrFnCacheParam[Z]
final def divide7[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G])(implicit evidence$21: ClassTag[A], evidence$22: ClassTag[B], evidence$23: ClassTag[C], evidence$24: ClassTag[D], evidence$25: ClassTag[E], evidence$26: ClassTag[F], evidence$27: ClassTag[G]): StrFnCacheParam[Z]
final def divide8[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H])(implicit evidence$28: ClassTag[A], evidence$29: ClassTag[B], evidence$30: ClassTag[C], evidence$31: ClassTag[D], evidence$32: ClassTag[E], evidence$33: ClassTag[F], evidence$34: ClassTag[G], evidence$35: ClassTag[H]): StrFnCacheParam[Z]
final def divide9[A <: Z, B <: Z, C <: Z, D <: Z, E <: Z, F <: Z, G <: Z, H <: Z, I <: Z, Z](cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I])(implicit evidence$36: ClassTag[A], evidence$37: ClassTag[B], evidence$38: ClassTag[C], evidence$39: ClassTag[D], evidence$40: ClassTag[E], evidence$41: ClassTag[F], evidence$42: ClassTag[G], evidence$43: ClassTag[H], evidence$44: ClassTag[I]): StrFnCacheParam[Z]

Implicits

Implicits

final implicit def tuple10[A, B, C, D, E, F, G, H, I, J](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J)]
final implicit def tuple11[A, B, C, D, E, F, G, H, I, J, K](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K)]
final implicit def tuple12[A, B, C, D, E, F, G, H, I, J, K, L](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L)]
final implicit def tuple13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M)]
final implicit def tuple14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]
final implicit def tuple15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
final implicit def tuple16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
final implicit def tuple17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]
final implicit def tuple18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
final implicit def tuple19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]
final implicit def tuple2[A, B](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B]): StrFnCacheParam[(A, B)]
final implicit def tuple20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]
final implicit def tuple21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T], cU: StrFnCacheParam[U]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]
final implicit def tuple22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I], cJ: StrFnCacheParam[J], cK: StrFnCacheParam[K], cL: StrFnCacheParam[L], cM: StrFnCacheParam[M], cN: StrFnCacheParam[N], cO: StrFnCacheParam[O], cP: StrFnCacheParam[P], cQ: StrFnCacheParam[Q], cR: StrFnCacheParam[R], cS: StrFnCacheParam[S], cT: StrFnCacheParam[T], cU: StrFnCacheParam[U], cV: StrFnCacheParam[V]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]
final implicit def tuple3[A, B, C](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C]): StrFnCacheParam[(A, B, C)]
final implicit def tuple4[A, B, C, D](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D]): StrFnCacheParam[(A, B, C, D)]
final implicit def tuple5[A, B, C, D, E](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E]): StrFnCacheParam[(A, B, C, D, E)]
final implicit def tuple6[A, B, C, D, E, F](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F]): StrFnCacheParam[(A, B, C, D, E, F)]
final implicit def tuple7[A, B, C, D, E, F, G](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G]): StrFnCacheParam[(A, B, C, D, E, F, G)]
final implicit def tuple8[A, B, C, D, E, F, G, H](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H]): StrFnCacheParam[(A, B, C, D, E, F, G, H)]
final implicit def tuple9[A, B, C, D, E, F, G, H, I](implicit cA: StrFnCacheParam[A], cB: StrFnCacheParam[B], cC: StrFnCacheParam[C], cD: StrFnCacheParam[D], cE: StrFnCacheParam[E], cF: StrFnCacheParam[F], cG: StrFnCacheParam[G], cH: StrFnCacheParam[H], cI: StrFnCacheParam[I]): StrFnCacheParam[(A, B, C, D, E, F, G, H, I)]