Transforming between case classes with context bounds

[q-jamesbruce]

Hello,

We're currently migrating our codebase from 0.7.5 trying to get to latest (1.7.3 at time of writing).

There appears to be a change of behaviour when transforming between case classes that have type parameters with context bounds.

With the following toy code:

import io.scalaland.chimney.dsl._

case class Source[A: Ordering](value: A)
case class Target[A: Ordering](value: A)

Source[Int](1).into[Target[Int]].transform

Things work on 0.7.5, but not on 1.7.3 (trying in Scastie it seems to be 0.8.0 when this changed), giving the compile error:

Chimney can't derive transformation from Playground.Source[scala.Int] to Playground.Target[scala.Int]

Playground.Target[scala.Int]
  evidence$2: scala.math.Ordering[scala.Int] - no accessor named evidence$2 in source type Playground.Source[scala.Int]


Consult https://chimney.readthedocs.io for usage examples.

This somewhat makes sense, I can understand the implicit parameters being given names under the hood, which is what the chimney macros see, and similarly the implicit is expected from the source.

My question is: what would be a best practice pattern to follow for transforming between case classes with context bounds?

[MateuszKubuszok]

To be honest it was a pure accident that it worked on older versions, I believe we might have used quasiquotes somewhere and they resolved implicits during splicing - making the whole macro code unaware that there was an implicit to handle, and how to proceed when it's missing. It must've disappear while rewriting code to format that could keep behavior consistent between Scala 2.12/2.13/3.

I think it's generally an antipattern to use implicits in case classes (or use any case classes with multiple parameters lists - many libraries simply do not support this), but if you already committed to them:

1. you can provide custom constructor which would have them applied:

   Source[Int](1)
    .into[Target[Int]]
    .withConstructor { (value: Int) =>
      Target(value) // implicit would be applied here, outside of macro
    }
    .transform

2. you can provide them as default values

   // while Target[Int] does not define a default value, this
   // allows macro to act like it did
   implicit def defaultOrdering[A: Ordering]
       : io.scalaland.chimney.integrations.DefaultValue[Ordering[A]] =
     () => implicitly[Ordering[A]]
    
   Source[Int](1).into[Target[Int]].enableDefaultValues.transform

3. if you name the implicit it would be possible to target it/rename it/provide const etc

   case class Source2[A](value: A)(implicit val ordering: Ordering[A]) // exposing implicit as val
   case class Target2[A](value: A)(implicit val ordering: Ordering[A])
    
   Source2[Int](1).into[Target2[Int]].transform
   Source2[Int](1).into[Target2[Int]].withFieldConst(_.ordering, Ordering[Int]).transform

ATM Chimney does not support resolving arbitrary implicits as arguments, someone would have to implement it:

• for starters the code that analyzes the constructor would have to have an additional isImplicit argument
• then the code for fallbacks would have to have an additional case for implicits
• this code should be behind a new opt-in flag