Consolidate ReusableFn into Reusable

Author: japgolly

doc/PERFORMANCE.md

@@ -20,7 +20,7 @@ libraryDependencies += "com.github.japgolly.scalajs-react" %%% "extra" % "0.11.3
   - [Usage](#usage)
   - [Example](#example)
   - [Monitoring](#monitoring)
-- [`ReusableFn`](#reusablefn)
+- [`Reusable.fn`](#reusablefn)
   - [Usage](#usage-1)
   - [Example](#example-1)
   - [Warning](#warning)
@@ -132,21 +132,21 @@ Usage:
 ```
 
 
-`ReusableFn`
+`Reusable.fn`
 ============
 
 In effective usage of React, callbacks are passed around as component properties.
 Due to the ease of function creation in Scala it is often the case that functions are created inline and thus
 provide no means of determining whether a component can safely skip its update.
 
-`ReusableFn` exists as a solution. It is a wrapper around a function that allows it to be both reused, and curried in a way that allows reuse.
+`Reusable.fn` exists as a solution. It is a wrapper around a function that allows it to be both reused, and curried in a way that allows reuse.
 
 #### Usage
 
-1. Just wrap `ReusableFn` around your function.
-2. Store the `ReusableFn` as a `val` somewhere outside of your `render` function, usually in the body of your backend class.
-3. Replace the callback (say `A => B`) in components' props, to take a `ReusableFn[A, B]` or the shorthand `A ~=> B`.
-4. Treat the `ReusableFn` as you would a normal function, save for one difference: application is curried (or Schönfinkel'ed), and each curried argument must have `Reusability`.
+1. Just wrap `Reusable.fn` around your function.
+2. Store the `Reusable.fn` as a `val` somewhere outside of your `render` function, usually in the body of your backend class.
+3. Replace the callback (say `A => B`) in components' props, to take a `Reusable.fn[A, B]` or the shorthand `A ~=> B`.
+4. Treat the `Reusable.fn` as you would a normal function, save for one difference: application is curried (or Schönfinkel'ed), and each curried argument must have `Reusability`.
 
 #### Example
 
@@ -164,7 +164,7 @@ val topComponent = ScalaComponent.build[State]("Demo")
 
 class Backend($: BackendScope[_, State]) {
 
-  val updateUser = ReusableFn((id: PersonId, data: PersonData) =>         // ← Create a 2-arg fn
+  val updateUser = Reusable.fn((id: PersonId, data: PersonData) =>         // ← Create a 2-arg fn
     $.modState(map => map.updated(id, data)))
 
   def render(state: State) =
@@ -190,7 +190,7 @@ val personEditor = ScalaComponent.build[PersonEditorProps]("PersonEditor")
 
 #### WARNING!
 
-**DO NOT** feed the `ReusableFn(...)` constructor a function directly *derived* from a component's props or state.
+**DO NOT** feed the `Reusable.fn(...)` constructor a function directly *derived* from a component's props or state.
 Access to props/state on the right-hand side of the function args is ok but if the function itself is a result of the
 props/state, the function will forever be based on data that can go stale.
 
@@ -200,25 +200,25 @@ Example:
 case class Props(person: StateSnapshot[Person], other: Other)
 
 // THIS IS BAD!!
-ReusableFn($.props.runNow().person setL Props.name)
+Reusable.fn($.props.runNow().person setL Props.name)
 
 // It is equivalent to:
 val g: String => Callback  = $.props.runNow().person setL Person.name   // ← $.props is evaluated once here
-val f: String ~=> Callback = ReusableFn(g)                              // ← …and never again.
+val f: String ~=> Callback = Reusable.fn(g)                              // ← …and never again.
 ```
 
 Alternatives:
 
-1. Use `ReusableFn.byName`:
+1. Use `Reusable.fn.byName`:
 
    ```scala
-   ReusableFn.byName($.props.runNow().person setL Person.name)
+   Reusable.fn.byName($.props.runNow().person setL Person.name)
    ```
 
 2. Create a function with `$` on the right-hand side:
 
    ```scala
-   ReusableFn(str => $.props.flatMap(_.person.setL(Person.name)(str)))
+   Reusable.fn(str => $.props.flatMap(_.person.setL(Person.name)(str)))
    ```
 
 
@@ -227,18 +227,18 @@ Alternatives:
 To cater for some common use cases, there are few convenience methods that are useful to know.
 For these examples imagine `$` to be your component's scope instance, eg. `BackendScope[_,S]`, `CompScope.Mounted[_,S,_,_]` or similar.
 
-1. `ReusableFn($).{set,mod}State`.
+1. `Reusable.fn($).{set,mod}State`.
 
-    You'll find that if you try `ReusableFn($.method)` Scala will fail to infer the correct types.
-    Use `ReusableFn($).method` instead to get the types that you expect.
+    You'll find that if you try `Reusable.fn($.method)` Scala will fail to infer the correct types.
+    Use `Reusable.fn($).method` instead to get the types that you expect.
 
-    Example: instead of `ReusableFn($.setState)` use `ReusableFn.state($).set` and you will correctly get a `S ~=> Callback`.
+    Example: instead of `Reusable.fn($.setState)` use `Reusable.fn.state($).set` and you will correctly get a `S ~=> Callback`.
 
-2. `ReusableFn.endo____`.
+2. `Reusable.fn.endo____`.
 
-    Anytime the input to your `ReusableFn` is an endofunction (`A => A`), additional methods starting with `endo` become available.
+    Anytime the input to your `Reusable.fn` is an endofunction (`A => A`), additional methods starting with `endo` become available.
 
-    Specifically, `ReusableFn.state($).mod` returns a `(S => S) ~=> Callback` which you will often want to transform.
+    Specifically, `Reusable.fn.state($).mod` returns a `(S => S) ~=> Callback` which you will often want to transform.
     These examples would be available on an `(S => S) ~=> U`:
 
     * `endoCall (S => (A => S)): A ~=> U` - Call a 1-arg function on `S`.
@@ -253,19 +253,19 @@ For these examples imagine `$` to be your component's scope instance, eg. `Backe
 
     // Manual long-hand
     val long: Int ~=> (String ~=> Callback) =
-      ReusableFn((id: Int, data: String) => $.modState(map => map.updated(id, data)))
+      Reusable.fn((id: Int, data: String) => $.modState(map => map.updated(id, data)))
 
     // Shorter using helpers described above
     val short: Int ~=> (String ~=> Callback) =
-      ReusableFn.state($).mod.endoCall2(_.updated)
+      Reusable.fn.state($).mod.endoCall2(_.updated)
   ```
 
-3. `ReusableFn($ zoomStateL lens)`
+3. `Reusable.fn($ zoomStateL lens)`
 
   Lenses provide an abstraction over read-and-write field access.
   Using Monocle, you can annotate your case classes with `@Lenses` to gain automatic lenses.
   `$ zoomStateL lens` will then narrow the scope of its state to the field targeted by the given lens.
-  This can then be used with `ReusableFn` as follows:
+  This can then be used with `Reusable.fn` as follows:
 
   ```scala
   @Lenses
@@ -274,7 +274,7 @@ For these examples imagine `$` to be your component's scope instance, eg. `Backe
   class Backend($: BackendScope[_, Person]) {
 
     val nameSetter: String ~=> Callback =
-      ReusableFn($ zoomL Person.name).setState
+      Reusable.fn($ zoomL Person.name).setState
   ```
 
 

extra/src/main/scala/japgolly/scalajs/react/extra/Reusable.scala

@@ -1,6 +1,7 @@
 package japgolly.scalajs.react.extra
 
 import scala.reflect.ClassTag
+import japgolly.scalajs.react.{Callback, StateAccessor}
 
 final class Reusable[+A] private[Reusable](valueByNeed: () => A,
                                            private[Reusable] val root: Any,
@@ -25,6 +26,9 @@ final class Reusable[+A] private[Reusable](valueByNeed: () => A,
 
 object Reusable {
 
+  @inline implicit def autoValue[A](r: Reusable[A]): A =
+    r.value
+
   private def root[A](a: A, isReusable: Reusable[Any] => Boolean): Reusable[A] =
     new Reusable[A](() => a, a, isReusable)
 
@@ -72,5 +76,175 @@ object Reusable {
 
   implicit def reusableReusability[A]: Reusability[Reusable[A]] =
     reusabilityInstance.narrow
-}
 
+  // ===================================================================================================================
+
+  /**
+   * A function that facilitates stability and reuse.
+   *
+   * In effective usage of React, callbacks are passed around as component properties.
+   * Due to the ease of function creation in Scala it is often the case that functions are created inline and thus
+   * provide no means of determining whether a component can safely skip its update.
+   * This exists as a solution.
+   *
+   * @since 0.9.0
+   */
+  object fn {
+    import FnInternals._
+
+    def apply[Y, Z](f: Y => Z): Y ~=> Z =
+      Reusable.implicitly(new Fn1(f))
+
+    def apply[A: Reusability, Y, Z](f: (A, Y) => Z): A ~=> (Y ~=> Z) =
+      Reusable.implicitly(new Fn2(f))
+
+    def apply[A: Reusability, B: Reusability, Y, Z](f: (A, B, Y) => Z): A ~=> (B ~=> (Y ~=> Z)) =
+      Reusable.implicitly(new Fn3(f))
+
+    def apply[A: Reusability, B: Reusability, C: Reusability, Y, Z](f: (A, B, C, Y) => Z): A ~=> (B ~=> (C ~=> (Y ~=> Z))) =
+      Reusable.implicitly(new Fn4(f))
+
+    def apply[A: Reusability, B: Reusability, C: Reusability, D: Reusability, Y, Z](f: (A, B, C, D, Y) => Z): A ~=> (B ~=> (C ~=> (D ~=> (Y ~=> Z)))) =
+      Reusable.implicitly(new Fn5(f))
+
+    def apply[A: Reusability, B: Reusability, C: Reusability, D: Reusability, E: Reusability, Y, Z](f: (A, B, C, D, E, Y) => Z): A ~=> (B ~=> (C ~=> (D ~=> (E ~=> (Y ~=> Z))))) =
+      Reusable.implicitly(new Fn6(f))
+
+    def state[I, S](i: I)(implicit t: StateAccessor.WriteCB[I, S]) = new StateAccessWriteOps(i)(t)
+    final class StateAccessWriteOps[I, S](i: I)(implicit t: StateAccessor.WriteCB[I, S]) {
+
+      def mod: (S => S) ~=> Callback =
+        Reusable.fn(t modState i)
+
+      def set: S ~=> Callback =
+        Reusable.fn(t setState i)
+    }
+  }
+
+  // ===================================================================================================================
+
+  private object FnInternals {
+    private type R[A] = Reusability[A]
+    type ReusableFn[-A, +B] = scala.runtime.AbstractFunction1[A, B]
+
+    // -------------------------------------------------------------------------
+
+    class Fn1[-Y, +Z](val f: Y => Z) extends ReusableFn[Y, Z] {
+      override def apply(a: Y) = f(a)
+    }
+
+    private val _reusabilityFn1: Reusability[Fn1[_, _]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityFn1[Y, Z]: Reusability[Fn1[Y, Z]] =
+      _reusabilityFn1.narrow
+
+    // -------------------------------------------------------------------------
+
+    class Fn2[A: R, -Y, +Z](val f: (A, Y) => Z) extends ReusableFn[A, Y ~=> Z] {
+      override def apply(a: A) = Reusable.implicitly(new Cur2(a, f))
+    }
+
+    class Cur2[A, -Y, +Z](val a: A, val f: (A, Y) => Z) extends ReusableFn[Y, Z] {
+      override def apply(y: Y): Z = f(a, y)
+    }
+
+    private val _reusabilityFn2: Reusability[Fn2[_, _, _]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityFn2[A, Y, Z]: Reusability[Fn2[A, Y, Z]] =
+      _reusabilityFn2.narrow
+
+    implicit def reusabilityCur2[A: R, Y, Z]: Reusability[Cur2[A, Y, Z]] =
+      Reusability((x, y) => (x eq y) || ((x.f eq y.f) && (x.a ~=~ y.a)))
+
+    // -------------------------------------------------------------------------
+
+    class Fn3[A: R, B: R, -Y, +Z](val f: (A, B, Y) => Z) extends ReusableFn[A, B ~=> (Y ~=> Z)] {
+      private val c2 = cur3(f)
+      override def apply(a: A) = Reusable.implicitly(new Cur2(a, c2))
+    }
+
+    def cur3[A: R, B: R, Y, Z](f: (A, B, Y) => Z): (A, B) => (Y ~=> Z) =
+      (a, b) => Reusable.implicitly(new Cur3(a, b, f))
+
+    class Cur3[A, B, -Y, +Z](val a: A, val b: B, val f: (A, B, Y) => Z) extends ReusableFn[Y, Z] {
+      override def apply(y: Y): Z = f(a, b, y)
+    }
+
+    private val _reusabilityFn3: Reusability[Fn3[_, _, _, _]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityFn3[A, B, Y, Z]: Reusability[Fn3[A, B, Y, Z]] =
+      _reusabilityFn3.narrow
+
+    implicit def reusabilityCur3[A: R, B: R, Y, Z]: Reusability[Cur3[A, B, Y, Z]] =
+      Reusability((x, y) => (x eq y) || ((x.f eq y.f) && (x.a ~=~ y.a) && (x.b ~=~ y.b)))
+
+    // -------------------------------------------------------------------------
+
+    class Fn4[A: R, B: R, C: R, -Y, +Z](val f: (A, B, C, Y) => Z) extends ReusableFn[A, B ~=> (C ~=> (Y ~=> Z))] {
+      private val c3 = cur4(f)
+      private val c2 = cur3(c3)
+      override def apply(a: A) = Reusable.implicitly(new Cur2(a, c2))
+    }
+
+    def cur4[A: R, B: R, C: R, Y, Z](f: (A, B, C, Y) => Z): (A, B, C) => (Y ~=> Z) =
+      (a, b, c) => Reusable.implicitly(new Cur4(a, b, c, f))
+
+    class Cur4[A, B, C, -Y, +Z](val a: A, val b: B, val c: C, val f: (A, B, C, Y) => Z) extends ReusableFn[Y, Z] {
+      override def apply(y: Y): Z = f(a, b, c, y)
+    }
+
+    implicit def reusabilityFn4[A, B, C, Y, Z]: Reusability[Fn4[A, B, C, Y, Z]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityCur4[A: R, B: R, C: R, Y, Z]: Reusability[Cur4[A, B, C, Y, Z]] =
+      Reusability((x, y) => (x eq y) || ((x.f eq y.f) && (x.a ~=~ y.a) && (x.b ~=~ y.b) && (x.c ~=~ y.c)))
+
+    // -------------------------------------------------------------------------
+
+    class Fn5[A: R, B: R, C: R, D: R, -Y, +Z](val f: (A, B, C, D, Y) => Z) extends ReusableFn[A, B ~=> (C ~=> (D ~=> (Y ~=> Z)))] {
+      private val c4 = cur5(f)
+      private val c3 = cur4(c4)
+      private val c2 = cur3(c3)
+      override def apply(a: A) = Reusable.implicitly(new Cur2(a, c2))
+    }
+
+    def cur5[A: R, B: R, C: R, D: R, Y, Z](f: (A, B, C, D, Y) => Z): (A, B, C, D) => (Y ~=> Z) =
+      (a, b, c, d) => Reusable.implicitly(new Cur5(a, b, c, d, f))
+
+    class Cur5[A, B, C, D, -Y, +Z](val a: A, val b: B, val c: C, val d: D, val f: (A, B, C, D, Y) => Z) extends ReusableFn[Y, Z] {
+      override def apply(y: Y): Z = f(a, b, c, d, y)
+    }
+
+    implicit def reusabilityFn5[A, B, C, D, Y, Z]: Reusability[Fn5[A, B, C, D, Y, Z]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityCur5[A: R, B: R, C: R, D: R, Y, Z]: Reusability[Cur5[A, B, C, D, Y, Z]] =
+      Reusability((x, y) => (x eq y) || ((x.f eq y.f) && (x.a ~=~ y.a) && (x.b ~=~ y.b) && (x.c ~=~ y.c) && (x.d ~=~ y.d)))
+
+    // -------------------------------------------------------------------------
+
+    class Fn6[A: R, B: R, C: R, D: R, E: R, -Y, +Z](val f: (A, B, C, D, E, Y) => Z) extends ReusableFn[A, B ~=> (C ~=> (D ~=> (E ~=> (Y ~=> Z))))] {
+      private val c5 = cur6(f)
+      private val c4 = cur5(c5)
+      private val c3 = cur4(c4)
+      private val c2 = cur3(c3)
+      override def apply(a: A) = Reusable.implicitly(new Cur2(a, c2))
+    }
+
+    def cur6[A: R, B: R, C: R, D: R, E: R, Y, Z](f: (A, B, C, D, E, Y) => Z): (A, B, C, D, E) => (Y ~=> Z) =
+      (a, b, c, d, e) => Reusable.implicitly(new Cur6(a, b, c, d, e, f))
+
+    class Cur6[A, B, C, D, E, -Y, +Z](val a: A, val b: B, val c: C, val d: D, val e: E, val f: (A, B, C, D, E, Y) => Z) extends ReusableFn[Y, Z] {
+      override def apply(y: Y): Z = f(a, b, c, d, e, y)
+    }
+
+    implicit def reusabilityFn6[A, B, C, D, E, Y, Z]: Reusability[Fn6[A, B, C, D, E, Y, Z]] =
+      Reusability((x, y) => (x eq y) || (x.f eq y.f))
+
+    implicit def reusabilityCur6[A: R, B: R, C: R, D: R, E: R, Y, Z]: Reusability[Cur6[A, B, C, D, E, Y, Z]] =
+      Reusability((x, y) => (x eq y) || ((x.f eq y.f) && (x.a ~=~ y.a) && (x.b ~=~ y.b) && (x.c ~=~ y.c) && (x.d ~=~ y.d) && (x.e ~=~ y.e)))
+  }
+}