despecialize epoch implementation to use Sum Type code path

Author: rmgk

Modules/RDTs/src/main/scala/rdts/base/Lattice.scala

@@ -154,33 +154,39 @@ object Lattice {
    * For an `enum E { case A, B, C }` it will be `A < B < C` */
   inline def sumLattice[T](using sm: Mirror.SumOf[T]): Lattice[T] =
     val lattices: Tuple = summonAll[Tuple.Map[sm.MirroredElemTypes, Lattice]]
-    new Derivation.SumLattice[T](sm, lattices)
+    new Derivation.SumLattice[T](Derivation.MirrorOrdinal(sm, lattices))
 
   inline def productLattice[T <: Product](using pm: Mirror.ProductOf[T]): Lattice[T] = {
     val lattices: Tuple = summonAll[Tuple.Map[pm.MirroredElemTypes, Lattice]]
     val bottoms: Tuple  = Derivation.summonAllMaybe[Tuple.Map[pm.MirroredElemTypes, Bottom]]
     new Derivation.ProductLattice[T](lattices, bottoms, pm, valueOf[pm.MirroredLabel])
   }
 
+  trait OrdinalLattices[T] {
+    def compare(left: T, right: T): Int
+    def lattice(elem: T): Lattice[T]
+  }
+
+
   object Derivation {
 
-    class SumLattice[T](sm: Mirror.SumOf[T], lattices: Tuple) extends Lattice[T] {
+    case class MirrorOrdinal[T](sm: Mirror.SumOf[T], lattices: Tuple) extends OrdinalLattices[T] {
+      def compare(left: T, right: T): Int = Integer.compare(sm.ordinal(left), sm.ordinal(right))
+      override def lattice(elem: T): Lattice[T] = lattices.productElement(sm.ordinal(elem)).asInstanceOf[Lattice[T]]
+    }
+
 
-      private def lat(i: Int): Lattice[T] = lattices.productElement(i).asInstanceOf[Lattice[T]]
+    class SumLattice[T](ol: OrdinalLattices[T]) extends Lattice[T] {
 
       def merge(left: T, right: T): T =
-        val lo = sm.ordinal(left)
-        val ro = sm.ordinal(right)
-        Integer.compare(lo, ro) match
-          case 0          => lat(lo).merge(left, right)
+        ol.compare(left, right) match
+          case 0          => ol.lattice(left).merge(left, right)
           case x if x < 0 => right
           case x if x > 0 => left
 
       override def subsumption(left: T, right: T): Boolean =
-        val lo = sm.ordinal(left)
-        val ro = sm.ordinal(right)
-        Integer.compare(lo, ro) match
-          case 0     => lat(lo).subsumption(left, right)
+        ol.compare(left, right) match
+          case 0     => ol.lattice(left).subsumption(left, right)
           case other => other < 0
     }
 

Modules/RDTs/src/main/scala/rdts/datatypes/Epoch.scala

@@ -1,5 +1,6 @@
 package rdts.datatypes
 
+import rdts.base.Lattice.OrdinalLattices
 import rdts.base.{Bottom, Decompose, Lattice}
 import rdts.dotted.HasDots
 import rdts.time.{Dots, Time}
@@ -33,19 +34,12 @@ object Epoch {
   given decomposeInstance[E: Decompose]: Decompose[Epoch[E]] =
     case Epoch(c, v) => Decompose.decompose(v).map(Epoch(c, _))
 
-  given latticeInstance[E: Lattice as E]: Lattice[Epoch[E]] = new Lattice[Epoch[E]] {
-
-    override def subsumption(left: Epoch[E], right: Epoch[E]): Boolean = (left, right) match {
-      case (Epoch(cLeft, vLeft), Epoch(cRight, vRight)) =>
-        cLeft < cRight || (cLeft == cRight && E.subsumption(vLeft, vRight))
-    }
-
-    /** By assumption: associative, commutative, idempotent. */
-    override def merge(left: Epoch[E], right: Epoch[E]): Epoch[E] = (left, right) match {
-      case (Epoch(cLeft, vLeft), Epoch(cRight, vRight)) =>
-        if cLeft > cRight then left
-        else if cRight > cLeft then right
-        else Epoch(cLeft, E.merge(vLeft, vRight))
-    }
+  given latticeInstance[E: Lattice as E]: Lattice[Epoch[E]] = {
+    given Lattice[Time] = Lattice.assertEquals
+    val prodEpoche = Lattice.productLattice[Epoch[E]]
+    Lattice.Derivation.SumLattice[Epoch[E]](new OrdinalLattices[Epoch[E]] {
+      override def compare(left: Epoch[E], right: Epoch[E]): Int = java.lang.Long.compare(left.counter, right.counter)
+      override def lattice(elem: Epoch[E]): Lattice[Epoch[E]]         = prodEpoche
+    })
   }
 }