Add Callback and CallbackTo, integrate everywhere

Fixes #145

Author: japgolly

core/src/main/scala/japgolly/scalajs/react/Callback.scala

@@ -0,0 +1,182 @@
+package japgolly.scalajs.react
+
+import scala.scalajs.js
+import js.{undefined, UndefOr, Function0 => JFn0, Function1 => JFn1}
+
+/**
+ * A callback with no return value. Equivalent to `() => Unit`.
+ *
+ * @see CallbackTo
+ */
+object Callback {
+  @inline def apply(f: => Unit): Callback =
+    CallbackTo(f)
+
+  @inline def lift(f: () => Unit): Callback =
+    CallbackTo lift f
+
+  @inline def lazily(f: => Callback): Callback =
+    Callback(f.runNow())
+
+  /** A callback that does nothing. */
+  val empty: Callback =
+    CallbackTo.pure(())
+}
+
+object CallbackTo {
+  @inline def apply[A](f: => A): CallbackTo[A] =
+    new CallbackTo(() => f)
+
+  @inline def lift[A](f: () => A): CallbackTo[A] =
+    new CallbackTo(f)
+
+  @inline def pure[A](a: A): CallbackTo[A] =
+    new CallbackTo(() => a)
+}
+
+/**
+ * A function to be executed later, usually by scalajs-react in response to some kind of event.
+ *
+ * The purpose of this class is to lift effects into the type system, and use the compiler to ensure safety around
+ * callbacks (without depending on an external library like Scalaz).
+ *
+ * `() => Unit` is replaced by `Callback`.
+ * Similarly, `ReactEvent => Unit` is replaced  by `ReactEvent => Callback`.
+ *
+ * @tparam A The type of result produced when the callback is invoked.
+ *
+ * @since 0.10.0
+ */
+final class CallbackTo[A] private[react] (private[CallbackTo] val f: () => A) extends AnyVal {
+
+  /**
+   * Executes this callback, on the current thread, right now, blocking until complete.
+   *
+   * In most cases, this type is passed to scalajs-react such that you don't need to call this method yourself.
+   *
+   * Exceptions will not be caught. Use [[attempt]] to catch thrown exceptions.
+   */
+  @inline def runNow(): A =
+    f()
+
+  def map[B](g: A => B): CallbackTo[B] =
+    new CallbackTo(() => g(f()))
+
+  def flatMap[B](g: A => CallbackTo[B]): CallbackTo[B] =
+    new CallbackTo(() => g(f()).f())
+
+  def flatten[B](implicit ev: A =:= CallbackTo[B]): CallbackTo[B] =
+    flatMap(ev)
+
+  /**
+   * Alias for `flatMap`.
+   */
+  @inline def >>=[B](g: A => CallbackTo[B]): CallbackTo[B] =
+    flatMap(g)
+
+  /**
+   * Same as `flatMap` and `>>=`, but allows arguments to appear in reverse order.
+   *
+   * i.e. `f >>= g` is the same as `g =<<: f`
+   */
+  @inline def =<<:[B](g: A => CallbackTo[B]): CallbackTo[B] =
+    flatMap(g)
+
+  /**
+   * Sequence a callback to run after this, discarding any value produced by this.
+   */
+  def >>[B](runNext: CallbackTo[B]): CallbackTo[B] =
+    //if (isEmpty_?) runNext else
+    //flatMap(_ => runNext)
+    new CallbackTo(() => {f(); runNext.f()})
+
+  /**
+   * Sequence a callback to run before this, discarding any value produced by it.
+   */
+  @inline def <<[B](runBefore: CallbackTo[B]): CallbackTo[A] =
+    runBefore >> this
+
+  /**
+   * Discard the value produced by this callback.
+   */
+  def void: Callback =
+    map(_ => ())
+
+  def conditionally(cond: => Boolean): CallbackTo[UndefOr[A]] =
+    CallbackTo(if (cond) f() else undefined)
+
+  /**
+   * Wraps this callback in a try-catch and returns either the result or the exception if one occurs.
+   */
+  def attempt: CallbackTo[Either[Throwable, A]] =
+    CallbackTo(
+      try Right(f())
+      catch { case t: Throwable => Left(t) }
+    )
+
+  /**
+   * Convenience-method to run additional code after this callback.
+   */
+  def thenRun[B](runNext: => B): CallbackTo[B] =
+    this >> CallbackTo(runNext)
+
+  /**
+   * Convenience-method to run additional code before this callback.
+   */
+  def precedeWith(runFirst: => Unit): CallbackTo[A] =
+    this << Callback(runFirst)
+
+  /**
+   * Wraps this callback in a try-finally block such that given code runs after the callback completes, be it in error
+   * or success.
+   */
+  def finallyRun(runFinally: => Unit): CallbackTo[A] =
+    CallbackTo(try f() finally runFinally)
+
+  @inline def toScalaFunction: () => A =
+    f
+
+  def toJsFunction: JFn0[A] =
+    f
+
+  def toJsFunction1: JFn1[Any, A] =
+    (_: Any) => f()
+
+  def toJsCallback: UndefOr[JFn0[A]] =
+    unlessEmpty(toJsFunction)
+
+  def isEmpty_? : Boolean =
+    f eq Callback.empty.f
+
+  def unlessEmpty[B](b: => B): UndefOr[B] =
+    if (isEmpty_?)
+      undefined
+    else
+      b
+
+  type TypeEv[T] = CallbackTo[A] =:= CallbackTo[T]
+
+  private def bool2(b: CallbackTo[Boolean])(op: (() => Boolean, () => Boolean) => Boolean)(implicit ev: TypeEv[Boolean]): CallbackTo[Boolean] = {
+    val x = ev(this).f
+    val y = b.f
+    CallbackTo(op(x, y))
+  }
+
+  /**
+   * Creates a new callback that returns `true` when both this and the given callback return `true`.
+   */
+  def &&(b: CallbackTo[Boolean])(implicit ev: TypeEv[Boolean]): CallbackTo[Boolean] =
+    bool2(b)(_() && _())
+
+  /**
+   * Creates a new callback that returns `true` when either this or the given callback return `true`.
+   */
+  def ||(b: CallbackTo[Boolean])(implicit ev: TypeEv[Boolean]): CallbackTo[Boolean] =
+    bool2(b)(_() || _())
+
+  /**
+   * Negates the callback result (so long as its boolean).
+   */
+  def !(implicit ev: A =:= Boolean): CallbackTo[Boolean] =
+    map(!_)
+}

core/src/main/scala/japgolly/scalajs/react/CompState.scala

@@ -1,13 +1,11 @@
 package japgolly.scalajs.react
 
-import scala.scalajs.js.{Function => JFn, undefined}
-
 /**
  * Generic read & write access to a component's state, (whatever the type of state might be).
  */
 abstract class CompStateAccess[-C, S] {
   def state(c: C): S
-  def setState(c: C, s: S, cb: OpCallback): Unit
+  def setState(c: C, s: S, cb: Callback): Callback
 }
 
 object CompStateAccess {
@@ -23,13 +21,13 @@ object CompStateAccess {
   }
 
   object Focus extends HK[CompStateFocus] {
-    override def state(c: C)                          = c.get()
-    override def setState(c: C, s: S, cb: OpCallback) = c.set(s, cb)
+    override def state(c: C)                        = c.get()
+    override def setState(c: C, s: S, cb: Callback) = c.set(s, cb)
   }
 
   object SS extends HK[ComponentScope_SS] {
-    override def state(c: C)                          = c._state.v
-    override def setState(c: C, s: S, cb: OpCallback) = c._setState(WrapObj(s), cb.map[JFn](f => f))
+    override def state(c: C)                        = c._state.v
+    override def setState(c: C, s: S, cb: Callback) = Callback(c._setState(WrapObj(s), cb.toJsCallback))
   }
 
   @inline implicit def focus[S]: CompStateAccess[CompStateFocus[S], S] =
@@ -51,20 +49,39 @@ object CompStateAccess {
     @inline def state(implicit C: CC): S =
       C.state(_c)
 
-    @inline def setState(s: S, cb: OpCallback = undefined)(implicit C: CC): Unit =
+    /**
+     * Creates a callback that always returns the latest state when run.
+     */
+    def stateCB(implicit C: CC): CallbackTo[S] =
+      CallbackTo(state)
+
+    def setState(s: S, cb: Callback = Callback.empty)(implicit C: CC): Callback =
       C.setState(_c, s, cb)
 
-    @inline def modState(f: S => S, cb: OpCallback = undefined)(implicit C: CC): Unit =
-      setState(f(state), cb)
+    def setStateCB(s: CallbackTo[S], cb: Callback = Callback.empty)(implicit C: CC): Callback =
+      s >>= (setState(_, cb))
+
+    def _setState[I](f: I => S, cb: Callback = Callback.empty)(implicit C: CC): I => Callback =
+      i => C.setState(_c, f(i), cb)
+
+    def modState(f: S => S, cb: Callback = Callback.empty)(implicit C: CC): Callback =
+      stateCB >>= (s => setState(f(s), cb))
+      //Callback lazily setState(f(state), cb)
+
+    def modStateCB(f: S => CallbackTo[S], cb: Callback = Callback.empty)(implicit C: CC): Callback =
+      stateCB >>= (s => setStateCB(f(s), cb))
+
+    def _modState[I](f: I => S => S, cb: Callback = Callback.empty)(implicit C: CC): I => Callback =
+      i => modState(f(i), cb)
 
     def lift(implicit C: CC) = new CompStateFocus[S](
       () => _c.state,
-      (a: S, cb: OpCallback) => _c.setState(a, cb))
+      (a: S, cb: Callback) => _c.setState(a, cb))
 
     /** Zoom-in on a subset of the state. */
     def zoom[T](f: S => T)(g: (S, T) => S)(implicit C: CC) = new CompStateFocus[T](
       () => f(_c.state),
-      (b: T, cb: OpCallback) => _c.setState(g(_c.state, b), cb))
+      (b: T, cb: Callback) => _c.setState(g(_c.state, b), cb))
   }
 }
 
@@ -74,9 +91,9 @@ object CompStateAccess {
  * @tparam S The type of state.
  */
 final class CompStateFocus[S] private[react](val get: () => S,
-                                             val set: (S, OpCallback) => Unit)
+                                             val set: (S, Callback) => Callback)
 
 object CompStateFocus {
-  @inline def apply[S](get: () => S)(set: (S, OpCallback) => Unit): CompStateFocus[S] =
+  @inline def apply[S](get: () => S)(set: (S, Callback) => Callback): CompStateFocus[S] =
     new CompStateFocus(get, set)
 }

core/src/main/scala/japgolly/scalajs/react/Internal.scala

@@ -4,22 +4,17 @@ import scala.scalajs.js._
 
 private[react] object Internal {
 
-  final class FnResults[R](aa: => R, bb: => R) {
-    lazy val a = aa
-    lazy val b = bb
-  }
-
-  final class FnComposer[R](m: FnResults[R] => R) {
+  final class FnComposer[R](compose: (=> R, => R) => R) {
     def apply[A](uf: UndefOr[A => R], g: A => R) =
-      uf.fold(g)(f => a => m(new FnResults(f(a), g(a))))
+      uf.fold(g)(f => a => compose(f(a), g(a)))
 
     def apply[A, B](uf: UndefOr[(A, B) => R], g: (A, B) => R) =
-      uf.fold(g)(f => (a,b) => m(new FnResults(f(a,b), g(a,b))))
+      uf.fold(g)(f => (a, b) => compose(f(a, b), g(a, b)))
 
     def apply[A, B, C](uf: UndefOr[(A, B, C) => R], g: (A, B, C) => R) =
-      uf.fold(g)(f => (a,b,c) => m(new FnResults(f(a,b,c), g(a,b,c))))
+      uf.fold(g)(f => (a, b, c) => compose(f(a, b, c), g(a, b, c)))
   }
 
-  val fcUnit = new FnComposer[Unit](r => {r.a; r.b})
-  val fcEither = new FnComposer[Boolean](r => r.a || r.b)
+  val fcUnit   = new FnComposer[Callback]           (_ >> _)
+  val fcEither = new FnComposer[CallbackTo[Boolean]](_ || _)
 }

core/src/main/scala/japgolly/scalajs/react/React.scala

@@ -221,7 +221,7 @@ trait ComponentScope_M[+Node <: TopNode] extends Object {
    * Can be invoked on any mounted component when you know that some deeper aspect of the component's state has
    * changed without using this.setState().
    */
-  def forceUpdate(): Unit = js.native
+  @JSName("forceUpdate") private[react] def _forceUpdate(): Unit = js.native
 }
 
 /** Type of an unmounted component's `this` scope. */