core/japgolly.scalagraal.util/CacheAndReplace

CacheAndReplace

@deprecated("Use StrFnCache instead.", "1.1.0")
object CacheAndReplace extends CacheAndReplaceBoilerplate

Takes a potentially slow String* => String function and makes it super fast by executing it once, optimising and caching the result, and then using it as template for all subsequent calls.

This assumes provided functions are pure (e.g. embedding the current time would be a violation).

This assumes provided functions treat their inputs as opaque values (e.g. inspecting an argument representing a username to provide "john" a different result than "mary" is a violation.)

Note: If you call compileN with a function that returns an japgolly.scalagraal.Expr and see an error about an implicit Functor not found, add this import:

 import cats.instances.either._
Deprecated
class Object
trait Matchable
class Any

Type members

Classlikes

final class Param[A](val fromStr: String => A, val toStr: A => String)
Companion:
object
object Param
Companion:
class

Value members

Inherited methods

def compile1[A](f: A => String)(implicit A: Param[A]): A => String
def compile10[A, B, C, D, E, F, G, H, I, J](f: (A, B, C, D, E, F, G, H, I, J) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J]): (A, B, C, D, E, F, G, H, I, J) => String
def compile11[A, B, C, D, E, F, G, H, I, J, K](f: (A, B, C, D, E, F, G, H, I, J, K) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K]): (A, B, C, D, E, F, G, H, I, J, K) => String
def compile12[A, B, C, D, E, F, G, H, I, J, K, L](f: (A, B, C, D, E, F, G, H, I, J, K, L) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L]): (A, B, C, D, E, F, G, H, I, J, K, L) => String
def compile13[A, B, C, D, E, F, G, H, I, J, K, L, M](f: (A, B, C, D, E, F, G, H, I, J, K, L, M) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M]): (A, B, C, D, E, F, G, H, I, J, K, L, M) => String
def compile14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => String
def compile15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => String
def compile16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => String
def compile17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => String
def compile18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => String
def compile19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => String
def compile2[A, B](f: (A, B) => String)(implicit A: Param[A], B: Param[B]): (A, B) => String
def compile20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => String
def compile21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T], U: Param[U]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => String
def compile22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T], U: Param[U], V: Param[V]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => String
def compile3[A, B, C](f: (A, B, C) => String)(implicit A: Param[A], B: Param[B], C: Param[C]): (A, B, C) => String
def compile4[A, B, C, D](f: (A, B, C, D) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D]): (A, B, C, D) => String
def compile5[A, B, C, D, E](f: (A, B, C, D, E) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E]): (A, B, C, D, E) => String
def compile6[A, B, C, D, E, F](f: (A, B, C, D, E, F) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F]): (A, B, C, D, E, F) => String
def compile7[A, B, C, D, E, F, G](f: (A, B, C, D, E, F, G) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G]): (A, B, C, D, E, F, G) => String
def compile8[A, B, C, D, E, F, G, H](f: (A, B, C, D, E, F, G, H) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H]): (A, B, C, D, E, F, G, H) => String
def compile9[A, B, C, D, E, F, G, H, I](f: (A, B, C, D, E, F, G, H, I) => String)(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I]): (A, B, C, D, E, F, G, H, I) => String
def compileF1[Z[_], A](f: A => Z[String])(implicit A: Param[A], Z: Functor[Z]): Z[A => String]
def compileF10[Z[_], A, B, C, D, E, F, G, H, I, J](f: (A, B, C, D, E, F, G, H, I, J) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J) => String]
def compileF11[Z[_], A, B, C, D, E, F, G, H, I, J, K](f: (A, B, C, D, E, F, G, H, I, J, K) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K) => String]
def compileF12[Z[_], A, B, C, D, E, F, G, H, I, J, K, L](f: (A, B, C, D, E, F, G, H, I, J, K, L) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L) => String]
def compileF13[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M](f: (A, B, C, D, E, F, G, H, I, J, K, L, M) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M) => String]
def compileF14[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N) => String]
def compileF15[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => String]
def compileF16[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => String]
def compileF17[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => String]
def compileF18[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => String]
def compileF19[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => String]
def compileF2[Z[_], A, B](f: (A, B) => Z[String])(implicit A: Param[A], B: Param[B], Z: Functor[Z]): Z[(A, B) => String]
def compileF20[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => String]
def compileF21[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T], U: Param[U], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => String]
def compileF22[Z[_], A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](f: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], J: Param[J], K: Param[K], L: Param[L], M: Param[M], N: Param[N], O: Param[O], P: Param[P], Q: Param[Q], R: Param[R], S: Param[S], T: Param[T], U: Param[U], V: Param[V], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => String]
def compileF3[Z[_], A, B, C](f: (A, B, C) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], Z: Functor[Z]): Z[(A, B, C) => String]
def compileF4[Z[_], A, B, C, D](f: (A, B, C, D) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], Z: Functor[Z]): Z[(A, B, C, D) => String]
def compileF5[Z[_], A, B, C, D, E](f: (A, B, C, D, E) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], Z: Functor[Z]): Z[(A, B, C, D, E) => String]
def compileF6[Z[_], A, B, C, D, E, F](f: (A, B, C, D, E, F) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], Z: Functor[Z]): Z[(A, B, C, D, E, F) => String]
def compileF7[Z[_], A, B, C, D, E, F, G](f: (A, B, C, D, E, F, G) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], Z: Functor[Z]): Z[(A, B, C, D, E, F, G) => String]
def compileF8[Z[_], A, B, C, D, E, F, G, H](f: (A, B, C, D, E, F, G, H) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H) => String]
def compileF9[Z[_], A, B, C, D, E, F, G, H, I](f: (A, B, C, D, E, F, G, H, I) => Z[String])(implicit A: Param[A], B: Param[B], C: Param[C], D: Param[D], E: Param[E], F: Param[F], G: Param[G], H: Param[H], I: Param[I], Z: Functor[Z]): Z[(A, B, C, D, E, F, G, H, I) => String]