Add util for creating InMemory impls

Author: japgolly

utils/js/src/main/scala/japgolly/microlibs/utils/package.scala

@@ -1,5 +1,5 @@
 package japgolly.microlibs
 
-package object utils {
+package object utils extends utils.PackageShared {
   val Platform: Platform = PlatformJS
 }

utils/jvm/src/main/scala/japgolly/microlibs/utils/package.scala

@@ -1,5 +1,5 @@
 package japgolly.microlibs
 
-package object utils {
+package object utils extends utils.PackageShared {
   val Platform: Platform = PlatformJVM
 }

utils/shared/src/main/scala/japgolly/microlibs/utils/IntIncrementer.scala

@@ -0,0 +1,60 @@
+package japgolly.microlibs.utils
+
+import java.util.concurrent.atomic.AtomicInteger
+
+object IntIncrementer {
+
+  trait Dsl[F[_]] {
+
+    def apply(): F[Int] =
+      apply(1)
+
+    def apply(startAt: Int): F[Int] =
+      apply(identity, startAt)
+
+    def apply[A](f: Int => A): F[A] =
+      apply(f, 1)
+
+    def apply[A](f: Int => A, startAt: Int): F[A]
+  }
+
+  // ===================================================================================================================
+
+  object threadUnsafe extends Dsl[Function0] {
+    override def apply[A](f: Int => A, startAt: Int): () => A = {
+      var prev = startAt
+      () => {
+        prev += 1
+        f(prev)
+      }
+    }
+  }
+
+  object volatile extends Dsl[Function0] {
+    override def apply[A](f: Int => A, startAt: Int): () => A = {
+      @volatile var prev = startAt
+      () => {
+        prev += 1
+        f(prev)
+      }
+    }
+  }
+
+  object cas extends Dsl[Function0] {
+    override def apply[A](f: Int => A, startAt: Int): () => A = {
+      val prev = new AtomicInteger(startAt)
+      () => f(prev.incrementAndGet())
+    }
+  }
+
+  def syncOn(lock: AnyRef): Dsl[Function0] =
+    new Dsl[Function0] {
+    override def apply[A](f: Int => A, startAt: Int): () => A = {
+      var prev = startAt
+      () => {
+        val n = lock.synchronized { prev += 1; prev }
+        f(n)
+      }
+    }
+  }
+}

utils/shared/src/main/scala/japgolly/microlibs/utils/LongIncrementer.scala

@@ -0,0 +1,60 @@
+package japgolly.microlibs.utils
+
+import java.util.concurrent.atomic.AtomicLong
+
+object LongIncrementer {
+
+  trait Dsl[F[_]] {
+
+    def apply(): F[Long] =
+      apply(1L)
+
+    def apply(startAt: Long): F[Long] =
+      apply(identity, startAt)
+
+    def apply[A](f: Long => A): F[A] =
+      apply(f, 1L)
+
+    def apply[A](f: Long => A, startAt: Long): F[A]
+  }
+
+  // ===================================================================================================================
+
+  object threadUnsafe extends Dsl[Function0] {
+    override def apply[A](f: Long => A, startAt: Long): () => A = {
+      var prev = startAt
+      () => {
+        prev += 1
+        f(prev)
+      }
+    }
+  }
+
+  object volatile extends Dsl[Function0] {
+    override def apply[A](f: Long => A, startAt: Long): () => A = {
+      @volatile var prev = startAt
+      () => {
+        prev += 1
+        f(prev)
+      }
+    }
+  }
+
+  object cas extends Dsl[Function0] {
+    override def apply[A](f: Long => A, startAt: Long): () => A = {
+      val prev = new AtomicLong(startAt)
+      () => f(prev.incrementAndGet())
+    }
+  }
+
+  def syncOn(lock: AnyRef): Dsl[Function0] =
+    new Dsl[Function0] {
+    override def apply[A](f: Long => A, startAt: Long): () => A = {
+      var prev = startAt
+      () => {
+        val n = lock.synchronized { prev += 1; prev }
+        f(n)
+      }
+    }
+  }
+}

utils/shared/src/main/scala/japgolly/microlibs/utils/MutableFn0.scala

@@ -0,0 +1,58 @@
+package japgolly.microlibs.utils
+
+import scala.runtime.AbstractFunction0
+
+trait MutableFn0[A] extends AbstractFunction0[A] {
+  def getFn: () => A
+  def setFn(f: () => A): this.type
+
+  final def set(f: => A): this.type =
+    setFn(() => f)
+}
+
+object MutableFn0 {
+
+  def fromVariable[A](v: Variable[() => A]): MutableFn0[A] =
+    new MutableFn0[A] {
+
+      override def apply(): A =
+        v.get()()
+
+      override def getFn: () => A =
+        v.get()
+
+      override def setFn(f: () => A): this.type = {
+        v.set(f)
+        this
+      }
+    }
+
+  class Dsl[A](make: (() => A) => Variable[() => A]) {
+
+    def apply(a: => A): MutableFn0[A] =
+      withFn(() => a)
+
+    def withFn(f: () => A): MutableFn0[A] =
+      MutableFn0.fromVariable(make(f))
+  }
+
+  class DslWithDefault[A](default: () => A, make: (() => A) => Variable[() => A]) extends Dsl(make) {
+    def apply(): MutableFn0[A] =
+      withFn(default)
+  }
+
+  class DslWithDefaultSelector[A](default: () => A) {
+    def threadUnsafe = new DslWithDefault[A](default, Variable(_))
+    def volatile = new DslWithDefault[A](default, Variable.volatile(_))
+    def syncOn(lock: AnyRef) = new DslWithDefault[A](default, Variable.syncOn(lock))
+  }
+
+  // ===================================================================================================================
+
+  def withDefault[A](a: => A): DslWithDefaultSelector[A] =
+    new DslWithDefaultSelector[A](() => a)
+
+  def threadUnsafe[A] = new Dsl[A](Variable(_))
+  def volatile[A] = new Dsl[A](Variable.volatile(_))
+  def syncOn[A](lock: AnyRef) = new Dsl[A](Variable.syncOn(lock))
+}

utils/shared/src/main/scala/japgolly/microlibs/utils/PackageShared.scala

@@ -0,0 +1,10 @@
+package japgolly.microlibs.utils
+
+import java.time.Instant
+
+trait PackageShared {
+
+  final type MutableClock = MutableFn0[Instant]
+  object MutableClock extends MutableFn0.DslWithDefaultSelector[Instant](() => Instant.now())
+
+}

utils/shared/src/main/scala/japgolly/microlibs/utils/Variable.scala

@@ -0,0 +1,39 @@
+package japgolly.microlibs.utils
+
+trait Variable[@specialized A] { self =>
+  def get(): A
+  def mod(f: A => A): A
+
+  def set(a: A): A =
+    mod(_ => a)
+
+  def xmap[B](f: A => B)(g: B => A): Variable[B] =
+    new Variable[B] {
+      override def get() = f(self.get())
+      override def mod(h: B => B) = f(self.mod(a => g(h(f(a)))))
+    }
+}
+
+object Variable {
+
+  def apply[@specialized A](init: A): Variable[A] =
+    new Variable[A] {
+      private[this] var value = init
+      override def get() = value
+      override def mod(f: A => A) = { value = f(value); value }
+    }
+
+  def volatile[@specialized A](init: A): Variable[A] =
+    new Variable[A] {
+      @volatile private[this] var value = init
+      override def get() = value
+      override def mod(f: A => A) = { value = f(value); value }
+    }
+
+  def syncOn[@specialized A](lock: AnyRef)(init: A): Variable[A] =
+    new Variable[A] {
+      private[this] var value = init
+      override def get() = lock.synchronized(value)
+      override def mod(f: A => A) = lock.synchronized { value = f(value); value }
+    }
+}