CaseClass1Rep support for Scala 3. Enabling kebs-instances.

akka-http/src/main/scala/pl/iterators/kebs/unmarshallers/enums/KebsEnumUnmarshallers.scala

@@ -8,25 +8,25 @@ import enumeratum.{Enum, EnumEntry}
 import pl.iterators.kebs.macros.enums.{EnumOf, ValueEnumOf}
 
 trait EnumUnmarshallers {
-  final def enumUnmarshaller[E <: EnumEntry](enum: Enum[E]): FromStringUnmarshaller[E] = Unmarshaller { _ => name =>
-    enum.withNameInsensitiveOption(name) match {
+  final def enumUnmarshaller[E <: EnumEntry](`enum`: Enum[E]): FromStringUnmarshaller[E] = Unmarshaller { _ =>name =>
+    `enum`.withNameInsensitiveOption(name) match {
       case Some(enumEntry) => FastFuture.successful(enumEntry)
       case None =>
-        FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$name'. Expected one of: ${enum.namesToValuesMap.keysIterator
+        FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$name'. Expected one of: ${`enum`.namesToValuesMap.keysIterator
           .mkString(", ")}"""))
     }
   }
 
   implicit def kebsEnumUnmarshaller[E <: EnumEntry](implicit ev: EnumOf[E]): FromStringUnmarshaller[E] =
-    enumUnmarshaller(ev.enum)
+    enumUnmarshaller(ev.`enum`)
 }
 
 trait ValueEnumUnmarshallers {
-  final def valueEnumUnmarshaller[V, E <: ValueEnumEntry[V]](enum: ValueEnum[V, E]): Unmarshaller[V, E] = Unmarshaller { _ => v =>
-    enum.withValueOpt(v) match {
+  final def valueEnumUnmarshaller[V, E <: ValueEnumEntry[V]](`enum`: ValueEnum[V, E]): Unmarshaller[V, E] = Unmarshaller { _ =>v =>
+    `enum`.withValueOpt(v) match {
       case Some(enumEntry) => FastFuture.successful(enumEntry)
       case None =>
-        FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$v'. Expected one of: ${enum.valuesToEntriesMap.keysIterator
+        FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$v'. Expected one of: ${`enum`.valuesToEntriesMap.keysIterator
           .mkString(", ")}"""))
     }
   }

build.sbt

@@ -426,7 +426,6 @@ lazy val instances = project
   .in(file("instances"))
   .settings(instancesSettings: _*)
   .settings(publishSettings: _*)
-  .settings(disableScala3)
   .settings(
     name := "instances",
     description := "Standard type mappings",

circe/src/main/scala/pl/iterators/kebs/circe/KebsEnumFormats.scala

@@ -7,57 +7,57 @@ import io.circe._
 import pl.iterators.kebs.macros.enums.{EnumOf, ValueEnumOf}
 
 trait CirceEnum {
-  @inline protected final def enumNameDeserializationError[E <: EnumEntry](enum: Enum[E], name: String): String = {
-    val enumNames = enum.namesToValuesMap.values.mkString(", ")
+  @inline protected final def enumNameDeserializationError[E <: EnumEntry](`enum`: Enum[E], name: String): String = {
+    val enumNames = `enum`.namesToValuesMap.values.mkString(", ")
     s"$name should be one of $enumNames"
   }
 
-  @inline protected final def enumValueDeserializationError[E <: EnumEntry](enum: Enum[E], value: Json): String = {
-    val enumNames = enum.namesToValuesMap.values.mkString(", ")
+  @inline protected final def enumValueDeserializationError[E <: EnumEntry](`enum`: Enum[E], value: Json): String = {
+    val enumNames = `enum`.namesToValuesMap.values.mkString(", ")
     s"$value should be a string of value $enumNames"
   }
 
-  protected final def enumDecoder[E <: EnumEntry](enum: Enum[E], _comap: String => Option[E]): Decoder[E] =
+  protected final def enumDecoder[E <: EnumEntry](`enum`: Enum[E], _comap: String => Option[E]): Decoder[E] =
     (c: HCursor) =>
-      Decoder.decodeString.emap(str => _comap(str).toRight("")).withErrorMessage(enumValueDeserializationError(enum, c.value))(c)
+      Decoder.decodeString.emap(str => _comap(str).toRight("")).withErrorMessage(enumValueDeserializationError(`enum`, c.value))(c)
 
-  protected final def enumEncoder[E <: EnumEntry](enum: Enum[E], _map: E => String): Encoder[E] =
+  protected final def enumEncoder[E <: EnumEntry](`enum`: Enum[E], _map: E => String): Encoder[E] =
     (obj: E) => Encoder.encodeString(_map(obj))
 
-  def enumDecoder[E <: EnumEntry](enum: Enum[E]): Decoder[E] =
-    enumDecoder[E](enum, enum.withNameInsensitiveOption(_))
-  def enumEncoder[E <: EnumEntry](enum: Enum[E]): Encoder[E] =
-    enumEncoder[E](enum, (e: EnumEntry) => e.entryName)
+  def enumDecoder[E <: EnumEntry](`enum`: Enum[E]): Decoder[E] =
+    enumDecoder[E](`enum`, `enum`.withNameInsensitiveOption(_))
+  def enumEncoder[E <: EnumEntry](`enum`: Enum[E]): Encoder[E] =
+    enumEncoder[E](`enum`, (e: EnumEntry) => e.entryName)
 
-  def lowercaseEnumDecoder[E <: EnumEntry](enum: Enum[E]): Decoder[E] =
-    enumDecoder[E](enum, enum.withNameLowercaseOnlyOption(_))
-  def lowercaseEnumEncoder[E <: EnumEntry](enum: Enum[E]): Encoder[E] =
-    enumEncoder[E](enum, (e: EnumEntry) => e.entryName.toLowerCase)
+  def lowercaseEnumDecoder[E <: EnumEntry](`enum`: Enum[E]): Decoder[E] =
+    enumDecoder[E](`enum`, `enum`.withNameLowercaseOnlyOption(_))
+  def lowercaseEnumEncoder[E <: EnumEntry](`enum`: Enum[E]): Encoder[E] =
+    enumEncoder[E](`enum`, (e: EnumEntry) => e.entryName.toLowerCase)
 
-  def uppercaseEnumDecoder[E <: EnumEntry](enum: Enum[E]): Decoder[E] =
-    enumDecoder[E](enum, enum.withNameUppercaseOnlyOption(_))
-  def uppercaseEnumEncoder[E <: EnumEntry](enum: Enum[E]): Encoder[E] =
-    enumEncoder[E](enum, (e: EnumEntry) => e.entryName.toUpperCase())
+  def uppercaseEnumDecoder[E <: EnumEntry](`enum`: Enum[E]): Decoder[E] =
+    enumDecoder[E](`enum`, `enum`.withNameUppercaseOnlyOption(_))
+  def uppercaseEnumEncoder[E <: EnumEntry](`enum`: Enum[E]): Encoder[E] =
+    enumEncoder[E](`enum`, (e: EnumEntry) => e.entryName.toUpperCase())
 }
 
 trait CirceValueEnum {
-  @inline protected final def valueEnumDeserializationError[V, E <: ValueEnumEntry[V]](enum: ValueEnum[V, E], value: Json): String = {
-    val enumValues = enum.valuesToEntriesMap.keys.mkString(", ")
+  @inline protected final def valueEnumDeserializationError[V, E <: ValueEnumEntry[V]](`enum`: ValueEnum[V, E], value: Json): String = {
+    val enumValues = `enum`.valuesToEntriesMap.keys.mkString(", ")
     s"$value is not a member of $enumValues"
   }
 
-  def valueEnumDecoder[V, E <: ValueEnumEntry[V]](enum: ValueEnum[V, E])(implicit decoder: Decoder[V]): Decoder[E] =
+  def valueEnumDecoder[V, E <: ValueEnumEntry[V]](`enum`: ValueEnum[V, E])(implicit decoder: Decoder[V]): Decoder[E] =
     (c: HCursor) =>
-      decoder.emap(obj => enum.withValueOpt(obj).toRight("")).withErrorMessage(valueEnumDeserializationError(enum, c.value))(c)
+      decoder.emap(obj => `enum`.withValueOpt(obj).toRight("")).withErrorMessage(valueEnumDeserializationError(`enum`, c.value))(c)
 
-  def valueEnumEncoder[V, E <: ValueEnumEntry[V]](enum: ValueEnum[V, E])(implicit encoder: Encoder[V]): Encoder[E] =
+  def valueEnumEncoder[V, E <: ValueEnumEntry[V]](`enum`: ValueEnum[V, E])(implicit encoder: Encoder[V]): Encoder[E] =
     (obj: E) => encoder(obj.value)
 }
 
 trait KebsEnumFormats extends CirceEnum with CirceValueEnum {
-  implicit def enumDecoder[E <: EnumEntry](implicit ev: EnumOf[E]): Decoder[E] = enumDecoder(ev.enum)
+  implicit def enumDecoder[E <: EnumEntry](implicit ev: EnumOf[E]): Decoder[E] = enumDecoder(ev.`enum`)
 
-  implicit def enumEncoder[E <: EnumEntry](implicit ev: EnumOf[E]): Encoder[E] = enumEncoder(ev.enum)
+  implicit def enumEncoder[E <: EnumEntry](implicit ev: EnumOf[E]): Encoder[E] = enumEncoder(ev.`enum`)
 
   implicit def valueEnumDecoder[V, E <: ValueEnumEntry[V]](implicit ev: ValueEnumOf[V, E], decoder: Decoder[V]): Decoder[E] =
     valueEnumDecoder(ev.valueEnum)
@@ -67,18 +67,18 @@ trait KebsEnumFormats extends CirceEnum with CirceValueEnum {
 
   trait Uppercase extends CirceEnum {
     implicit def enumDecoder[E <: EnumEntry](implicit ev: EnumOf[E]): Decoder[E] =
-      uppercaseEnumDecoder(ev.enum)
+      uppercaseEnumDecoder(ev.`enum`)
 
     implicit def enumEncoder[E <: EnumEntry](implicit ev: EnumOf[E]): Encoder[E] =
-      uppercaseEnumEncoder(ev.enum)
+      uppercaseEnumEncoder(ev.`enum`)
   }
 
   trait Lowercase extends CirceEnum {
     implicit def enumDecoder[E <: EnumEntry](implicit ev: EnumOf[E]): Decoder[E] =
-      lowercaseEnumDecoder(ev.enum)
+      lowercaseEnumDecoder(ev.`enum`)
 
     implicit def enumEncoder[E <: EnumEntry](implicit ev: EnumOf[E]): Encoder[E] =
-      lowercaseEnumEncoder(ev.enum)
+      lowercaseEnumEncoder(ev.`enum`)
   }
 }
 

examples/src/main/scala/pl/iterators/kebs_examples/AkkaHttpUnmarshallers.scala

@@ -31,19 +31,19 @@ object AkkaHttpUnmarshallers {
   case class PaginationQuery(sortBy: Column, sortOrder: SortOrder, offset: Offset, limit: Limit)
 
   object BeforeKebs {
-    final def enumUnmarshaller[E <: EnumEntry](enum: Enum[E]): FromStringUnmarshaller[E] = Unmarshaller { _ => name =>
-      enum.withNameInsensitiveOption(name) match {
+    final def enumUnmarshaller[E <: EnumEntry](`enum`: Enum[E]): FromStringUnmarshaller[E] = Unmarshaller { _ =>name =>
+      `enum`.withNameInsensitiveOption(name) match {
         case Some(enumEntry) => FastFuture.successful(enumEntry)
         case None =>
-          FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$name'. Expected one of: ${enum.namesToValuesMap.keysIterator
+          FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$name'. Expected one of: ${`enum`.namesToValuesMap.keysIterator
             .mkString(", ")}"""))
       }
     }
-    final def valueEnumUnmarshaller[V, E <: ValueEnumEntry[V]](enum: ValueEnum[V, E]): Unmarshaller[V, E] = Unmarshaller { _ => v =>
-      enum.withValueOpt(v) match {
+    final def valueEnumUnmarshaller[V, E <: ValueEnumEntry[V]](`enum`: ValueEnum[V, E]): Unmarshaller[V, E] = Unmarshaller { _ =>v =>
+      `enum`.withValueOpt(v) match {
         case Some(enumEntry) => FastFuture.successful(enumEntry)
         case None =>
-          FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$v'. Expected one of: ${enum.valuesToEntriesMap.keysIterator
+          FastFuture.failed(new IllegalArgumentException(s"""Invalid value '$v'. Expected one of: ${`enum`.valuesToEntriesMap.keysIterator
             .mkString(", ")}"""))
       }
     }

instances/src/test/scala/pl/iterators/kebs/instances/net/NetInstancesTests.scala

@@ -1,13 +1,13 @@
 package pl.iterators.kebs.instances.net
 
 import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers.convertToAnyShouldWrapper
+import org.scalatest.matchers.should.Matchers
 import pl.iterators.kebs.instances.InstanceConverter
 import pl.iterators.kebs.instances.InstanceConverter.DecodeErrorException
 
 import java.net.URI
 
-class NetInstancesTests extends AnyFunSuite with URIString {
+class NetInstancesTests extends AnyFunSuite with Matchers with URIString {
 
   test("URI to String") {
     val ico   = implicitly[InstanceConverter[URI, String]]

macro-utils/src/main/scala-2/pl/iterators/kebs/macros/enums/EnumEntryMacros.scala

@@ -5,7 +5,7 @@ import enumeratum.{Enum, EnumEntry}
 import scala.language.experimental.macros
 import scala.reflect.macros.blackbox
 
-class EnumOf[E <: EnumEntry](val enum: Enum[E])
+class EnumOf[E <: EnumEntry](val `enum`: Enum[E])
 
 object EnumOf {
   implicit def enumOf[E <: EnumEntry]: EnumOf[E] = macro EnumEntryMacros.enumOfImpl[E]

macro-utils/src/main/scala-3/pl/iterators/kebs/macros/CaseClassReps.scala

@@ -1,3 +1,11 @@
 package pl.iterators.kebs.macros
 
+import scala.deriving.Mirror
+
 final class CaseClass1Rep[CC, F1](val apply: F1 => CC, val unapply: CC => F1)
+
+object CaseClass1Rep {
+  inline given[T <: Product, F1](using m: Mirror.ProductOf[T], teq: m.MirroredElemTypes =:= F1 *: EmptyTuple.type): CaseClass1Rep[T, F1] =  {
+    new CaseClass1Rep[T, F1](f1 => m.fromProduct(Tuple1(f1)), _.productElement(0).asInstanceOf[F1])
+  }
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/macros/enums/EnumEntryMacros.scala

@@ -0,0 +1,29 @@
+package pl.iterators.kebs.macros.enums
+
+import scala.quoted._
+
+trait EnumLike[T] {
+  def values: Array[T]
+  def valueOf(name: String): T
+  def fromOrdinal(ordinal: Int): T
+}
+
+class EnumOf[E](val `enum`: EnumLike[E])
+
+object EnumOf {
+  inline given [E]: EnumOf[E] = ${EnumOf.impl[E]()}
+
+  private def impl[T]()(using Quotes, Type[T]): Expr[EnumOf[T]] = {
+    import quotes.reflect._
+    val companion = Ref(TypeRepr.of[T].typeSymbol.companionModule)
+    '{
+      new EnumOf(
+        new EnumLike[T] {
+          def values: Array[T] = ${Select.unique(companion, "values").asExprOf[Array[T]]}
+          def valueOf(name: String): T = ${Apply(Select.unique(companion, "valueOf"), List('{name}.asTerm)).asExprOf[T]}
+          def fromOrdinal(ordinal: Int): T = ${Apply(Select.unique(companion, "fromOrdinal"), List('{ordinal}.asTerm)).asExprOf[T]}
+        }
+      )
+    }
+  }
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/EquivSupport.scala

@@ -0,0 +1,10 @@
+package pl.iterators.kebs.support
+
+import pl.iterators.kebs.macros.CaseClass1Rep
+
+trait EquivSupport {
+
+  implicit def equivFromCaseClass1Rep[A, Rep](implicit cc1Rep: CaseClass1Rep[A, Rep], equivRep: Equiv[Rep]): Equiv[A] =
+    (x: A, y: A) => equivRep.equiv(cc1Rep.unapply(x), cc1Rep.unapply(y))
+
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/FractionalSupport.scala

@@ -0,0 +1,25 @@
+package pl.iterators.kebs.support
+
+import pl.iterators.kebs.macros.CaseClass1Rep
+
+trait FractionalSupport {
+
+  implicit def fractionalFromCaseClass1Rep[A, Rep](implicit cc1Rep: CaseClass1Rep[A, Rep],
+                                                   fractionalRep: Fractional[Rep],
+                                                   numeric: Numeric[A]): Fractional[A] =
+    new Fractional[A] {
+      override def div(x: A, y: A): A                  = cc1Rep.apply(fractionalRep.div(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def plus(x: A, y: A): A                 = numeric.plus(x, y)
+      override def minus(x: A, y: A): A                = numeric.minus(x, y)
+      override def times(x: A, y: A): A                = numeric.times(x, y)
+      override def negate(x: A): A                     = numeric.negate(x)
+      override def fromInt(x: Int): A                  = numeric.fromInt(x)
+      override def parseString(str: String): Option[A] = numeric.parseString(str)
+      override def toInt(x: A): Int                    = numeric.toInt(x)
+      override def toLong(x: A): Long                  = numeric.toLong(x)
+      override def toFloat(x: A): Float                = numeric.toFloat(x)
+      override def toDouble(x: A): Double              = numeric.toDouble(x)
+      override def compare(x: A, y: A): Int            = numeric.compare(x, y)
+    }
+
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/IntegralSupport.scala

@@ -0,0 +1,26 @@
+package pl.iterators.kebs.support
+
+import pl.iterators.kebs.macros.CaseClass1Rep
+
+trait IntegralSupport {
+
+  implicit def integralFromCaseClass1Rep[A, Rep](implicit cc1Rep: CaseClass1Rep[A, Rep],
+                                                 integralRep: Integral[Rep],
+                                                 numeric: Numeric[A]): Integral[A] =
+    new Integral[A] {
+      override def quot(x: A, y: A): A                 = cc1Rep.apply(integralRep.quot(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def rem(x: A, y: A): A                  = cc1Rep.apply(integralRep.rem(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def plus(x: A, y: A): A                 = numeric.plus(x, y)
+      override def minus(x: A, y: A): A                = numeric.minus(x, y)
+      override def times(x: A, y: A): A                = numeric.times(x, y)
+      override def negate(x: A): A                     = numeric.negate(x)
+      override def fromInt(x: Int): A                  = numeric.fromInt(x)
+      override def parseString(str: String): Option[A] = numeric.parseString(str)
+      override def toInt(x: A): Int                    = numeric.toInt(x)
+      override def toLong(x: A): Long                  = numeric.toLong(x)
+      override def toFloat(x: A): Float                = numeric.toFloat(x)
+      override def toDouble(x: A): Double              = numeric.toDouble(x)
+      override def compare(x: A, y: A): Int            = numeric.compare(x, y)
+    }
+
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/NumericSupport.scala

@@ -0,0 +1,23 @@
+package pl.iterators.kebs.support
+
+import pl.iterators.kebs.macros.CaseClass1Rep
+
+trait NumericSupport {
+
+  implicit def numericFromCaseClass1Rep[A, Rep](implicit cc1Rep: CaseClass1Rep[A, Rep], numericRep: Numeric[Rep]): Numeric[A] = {
+    new Numeric[A] {
+      override def plus(x: A, y: A): A                 = cc1Rep.apply(numericRep.plus(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def minus(x: A, y: A): A                = cc1Rep.apply(numericRep.minus(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def times(x: A, y: A): A                = cc1Rep.apply(numericRep.times(cc1Rep.unapply(x), cc1Rep.unapply(y)))
+      override def negate(x: A): A                     = cc1Rep.apply(numericRep.negate(cc1Rep.unapply(x)))
+      override def fromInt(x: Int): A                  = cc1Rep.apply(numericRep.fromInt(x))
+      override def toInt(x: A): Int                    = numericRep.toInt(cc1Rep.unapply(x))
+      override def toLong(x: A): Long                  = numericRep.toLong(cc1Rep.unapply(x))
+      override def toFloat(x: A): Float                = numericRep.toFloat(cc1Rep.unapply(x))
+      override def toDouble(x: A): Double              = numericRep.toDouble(cc1Rep.unapply(x))
+      override def compare(x: A, y: A): Int            = numericRep.compare(cc1Rep.unapply(x), cc1Rep.unapply(y))
+      override def parseString(str: String): Option[A] = numericRep.parseString(str).map(cc1Rep.apply)
+    }
+  }
+
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/PartialOrderingSupport.scala

@@ -0,0 +1,14 @@
+package pl.iterators.kebs.support
+
+import pl.iterators.kebs.macros.CaseClass1Rep
+
+trait PartialOrderingSupport {
+
+  implicit def partialOrderingFromCaseClass1Rep[A, Rep](implicit cc1Rep: CaseClass1Rep[A, Rep],
+                                                        partialOrderingRep: PartialOrdering[Rep]): PartialOrdering[A] =
+    new PartialOrdering[A] {
+      override def tryCompare(x: A, y: A): Option[Int] = partialOrderingRep.tryCompare(cc1Rep.unapply(x), cc1Rep.unapply(y))
+      override def lteq(x: A, y: A): Boolean           = partialOrderingRep.lteq(cc1Rep.unapply(x), cc1Rep.unapply(y))
+    }
+
+}

macro-utils/src/main/scala-3/pl/iterators/kebs/support/package.scala

@@ -0,0 +1,3 @@
+package pl.iterators.kebs
+
+package object support extends FractionalSupport with IntegralSupport with NumericSupport with PartialOrderingSupport with EquivSupport

macro-utils/src/test/scala-3/DerivingSpecification.scala

@@ -0,0 +1,22 @@
+import org.scalacheck.Prop.forAll
+import org.scalacheck.{Gen, Properties}
+import pl.iterators.kebs.macros.CaseClass1Rep
+import pl.iterators.kebs.macros.enums.EnumOf
+
+object DerivingSpecification extends Properties("Deriving") {
+  case class CC1Ex(whatever: String)
+
+  property("CaseClass1Rep derives properly from 1-element case class") = forAll { (stringValue: String) =>
+    val tc = implicitly[CaseClass1Rep[CC1Ex, String]]
+    tc.apply(stringValue) == CC1Ex(stringValue) && tc.unapply(CC1Ex(stringValue)) == stringValue
+  }
+
+  enum Color {
+    case Red, Green, Blue
+  }
+
+  property("EnumOf derives properly for an enum") = forAll(Gen.oneOf(Color.values.toList)) { (color: Color) =>
+    val tc = implicitly[EnumOf[Color]]
+    tc.`enum`.values.contains(color) && tc.`enum`.valueOf(color.toString) == color && tc.`enum`.fromOrdinal(color.ordinal) == color
+  }
+}