mapping opaque types

[andyczerwonka]

I like to use typed identifiers in my model layer, so was wondering what the best approach you be to map these. Assuming the following:

opaque type SubstanceId = Long
object SubstanceId {

  def parse(value: Long): Either[String, SubstanceId] = {
    if (value > 0) Right(value) else Left("SubstanceIds must be positive")
  }

  def fromLong(value: Long): SubstanceId = {
    require(value > 0, "SubstanceIds must be positive")
    value
  }

  extension (t: SubstanceId) {
    def toLong: Long = t
  }

}

My protos would include this in the Substance, using a simple uint64 as I wouldn't want to wrap that with anything as we want to make external clients as simple as possible. E.g.

message Substance {
  uint64 id = 1;
  string name = 2;
  repeated Property properties = 3;
  optional string description = 4;
}

case class Substance(
    id: SubstanceId,
    name: String,
    properties: Seq[Property],
    description: Option[String]
)

[MateuszKubuszok]

So, I would recommend not using raw opaque types but some library - opaque types on their own have:

• no Mirrors
• no easy way to see what's the underlying type in the macros (it's possible, although it requires -Yretain-trees)
• no convention how constructor/smart constructor is called, nor how to extract values - so even if you relate the opaque type to the underlying type in macros you are basically guessing what is smart constructor and what is extractor

which is why no library provides a support for them OOTB. On the other hand, all these newtype libraries (Monix Newtype, Neotypes, Refines4s, Iron, etc) enforce one way of defining opaque type, which allows them to provide some type classes standardizing how you can work with them - which enables Chimney to integrate with them if one wanted to perform Outer <=> Underlying conversion.

Alternatively, one can try to use ScalaPB type mappers so that protobufs would use opaque types already, so that Chimney would only move the field around without transforming its format.

I have to mention however, that opaque types had some bugs in Scala 3 macros, and they sometimes don't work as expected. YMMV