Creating generic transformers

[brndt]

Hello! I have one question regarding transformers. I have implemented Value Object pattern using opaque types so my validated data looks like this:

opaque type TeamName = String
object TeamName:
extension (value: TeamName) def value: String = value
def create(value: String): IO[InvalidTeamNameError, TeamName] =
ZIO.cond(value.inLengthRange(2 to 50), value, InvalidTeamNameError(value))

The problem that I have is that I can’t define generic transformers for these type of data because even if I extract ‘value’ method to common interface that is implemented by all necessary structure after, the generic transformers don’t work.

Is it somehow possible to create a generic transformer for this type of structures? I don't want to create a custom transformer for every opaque type.

PS: I've managed to resolve it by using case class and AnyVal as it is said in documentation but it would like to have a similar solution without overhead.

[arainko]

So generally it's not possible to abstract over 'raw' opaque types (or maybe it is, extensions do show up in the symbol list when reflected over 🤔) but that is easily addressable if you sprinkle some newtype magic over what you're currently doing:

trait Newtype[A] {
  opaque type Type = A

  def apply(value: A): Type = value

  def wrapAll[F[_]](unwrapped: F[A]): F[Type] = unwrapped

  def unwrapAll[F[_]](wrapped: F[Type]): F[A] = wrapped

  extension (self: Type) {
    def value: A = self
  }

  given wrappingTransformer: Transformer[A, Type] = apply

  given uwnrappingTransformer: Transformer[Type, A] = _.value
}

Given the above your example would look like this (impl taken from here):

object TypeName extends Newtype[String]
export TypeName.Type as TypeName

and all of the Transformers declared inside Newtype are automatically available in implicit scope for TypeNames so now when you call team.to[TeamView] it should all be resolved for you.

You could also take a look at a Newtype that does validation here.

But yeah as I said abstracting over raw opaque types is still an open question (I haven't seen a library that does it, it'd have to be by some kind of arbitrary convention eg. when you find a single arg apply method on the companion you use it for wrapping and if a .value extension is found you use it for unwrapping, dunno if any of that is possible tho 😄)

Hope I answered your question ❤️

[brndt]

arainko, thanks for such a detail response!
Yes, the approach you've showed worked for me.

And also thanks for the library, it's very useful.

[brndt]

Seems like this approach doesn't work for enums:

[arainko]

What's the expected semantic here? To generate a Transformer[TeamStatus, String] and vice versa I presume?

Oh actually after taking another look at it can you try this instead:

enum TeamStatus:
  case Enabled, Disabled

object TeamStatus extends Newtype[String](...)

Although I don't think newtypes are a good fit for this particular use case since what you're after in this case is an isomorphism between your enum and a String (or a refinement), a newtype isn't really that

[brndt]

I think this sadly will be a no go for enums, what's the expected semantic here? To generate a Transformer[TeamStatus, String] and vice versa I presume?

Yes. The only way I find it possible to do is by encapsulating enum in object, making something like this:

object TeamStatus
    extends Newtype[String](value => TeamStatus.Enum.values.has(value), value => InvalidTeamStatusError(value)):
  enum Enum:
    case Opened, Closed
export TeamStatus.Type as TeamStatus

[arainko]

Yeah, as I said newtypes is not something you use to express that something can be turned into something else and back (an isomorphism) 😄 You have to roll your own abstraction for that (maybe something like enumerarum could help?) or just create these Transformers by hand

[brndt]

@arainko hey, just another small question, is it possible to do a transformation when Destination is trait? I want to pass parameter type to the method but the compiler tells me that my generic parameter is not Product type

private def toEvent[P <: PlayerStatsEvent](matchId: Id, tournamentInformation: TournamentInformation) =
    this
      .into[P]
      .transform(
        Field.const(
          _.statsByTournament,
          TournamentStatsEvent(
            tournamentInformation.to[TournamentInformationEvent],
            matchId.value,
            null,
            this.overallStats.to[StatsEvent]
          )
        )
      )

And trait is represented as seen below:

sealed trait PlayerStatsEvent extends DomainEvent:
    val id: String
    val playerId: String
    val seasonId: String
    val statsByTournament: TournamentStatsEvent
    val overallStats: StatsEvent

final case class PlayerStatsCreated(
    id: String,
    playerId: String,
    seasonId: String,
    statsByTournament: TournamentStatsEvent,
    overallStats: StatsEvent
) extends PlayerStatsEvent

[arainko]

So, P is a type parameter (not a concrete type) the library is not able to get its strucuture (fields, types etc.)