Prototype OptionToOption and ToOption fallbacks

chimney-macro-commons/src/main/scala/io/scalaland/chimney/internal/compiletime/fp/Implicits.scala

@@ -34,4 +34,21 @@ object Implicits {
 
     def pure[A](a: A): List[A] = List(a)
   }
+
+  implicit val vectorApplicativeTraverse: ApplicativeTraverse[Vector] = new ApplicativeTraverse[Vector] {
+
+    def traverse[G[_]: Applicative, A, B](fa: Vector[A])(f: A => G[B]): G[Vector[B]] =
+      fa.foldLeft(new ListBuffer[B].pure[G]) { (bufferG, a) =>
+        bufferG.map2(f(a)) { (buf: ListBuffer[B], b: B) => buf.append(b); buf } // can't use append 'cause 2.12
+      }.map(_.toVector)
+
+    def parTraverse[G[_]: Parallel, A, B](fa: Vector[A])(f: A => G[B]): G[Vector[B]] =
+      fa.foldLeft(new ListBuffer[B].pure[G]) { (bufferG, a) =>
+        bufferG.parMap2(f(a)) { (buf: ListBuffer[B], b: B) => buf.append(b); buf } // can't use append 'cause 2.12
+      }.map(_.toVector)
+
+    def map2[A, B, C](fa: Vector[A], fb: Vector[B])(f: (A, B) => C): Vector[C] = fa.zip(fb).map(f.tupled)
+
+    def pure[A](a: A): Vector[A] = Vector(a)
+  }
 }

chimney/src/main/scala/io/scalaland/chimney/internal/compiletime/derivation/transformer/ResultOps.scala

@@ -28,12 +28,15 @@ private[compiletime] trait ResultOps { this: Derivation =>
     def existential[F[_], A: Type](fa: F[A]): DerivationResult[Existential[F]] =
       DerivationResult.pure(Existential[F, A](fa))
 
+    def totalExpr[To](expr: Expr[To]): DerivationResult[TransformationExpr[To]] =
+      DerivationResult.pure(TransformationExpr.fromTotal(expr))
+    def partialExpr[To](expr: Expr[partial.Result[To]]): DerivationResult[TransformationExpr[To]] =
+      DerivationResult.pure(TransformationExpr.fromPartial(expr))
+
     def expanded[To](expr: TransformationExpr[To]): DerivationResult[Rule.ExpansionResult[To]] =
       DerivationResult.pure(Rule.ExpansionResult.Expanded(expr))
-
     def expandedTotal[To](expr: Expr[To]): DerivationResult[Rule.ExpansionResult[To]] =
       DerivationResult.pure(Rule.ExpansionResult.Expanded(TransformationExpr.TotalExpr[To](expr)))
-
     def expandedPartial[To](expr: Expr[partial.Result[To]]): DerivationResult[Rule.ExpansionResult[To]] =
       DerivationResult.pure(Rule.ExpansionResult.Expanded(TransformationExpr.PartialExpr[To](expr)))
 

chimney/src/main/scala/io/scalaland/chimney/internal/compiletime/derivation/transformer/rules/TransformOptionToOptionRuleModule.scala

@@ -1,7 +1,9 @@
 package io.scalaland.chimney.internal.compiletime.derivation.transformer.rules
 
+import io.scalaland.chimney.dsl as dsls
 import io.scalaland.chimney.internal.compiletime.DerivationResult
 import io.scalaland.chimney.internal.compiletime.derivation.transformer.Derivation
+import io.scalaland.chimney.internal.compiletime.fp.Implicits.*
 import io.scalaland.chimney.partial
 
 private[compiletime] trait TransformOptionToOptionRuleModule {
@@ -22,8 +24,25 @@ private[compiletime] trait TransformOptionToOptionRuleModule {
             to2.{Underlying as InnerTo, value as optionalTo}
           DerivationResult.log(
             s"Resolved ${Type.prettyPrint[From]} (${from2.value}) and ${Type.prettyPrint[To]} (${to2.value}) as optional types"
-          ) >>
-            mapOptions[From, To, InnerFrom, InnerTo](optionalFrom, optionalTo)
+          ) >> {
+            def srcToResult = mapOptions[From, To, InnerFrom, InnerTo](optionalFrom, optionalTo)
+
+            def fallbackToResult = mapFallbackOptions[From, To, InnerTo](optionalTo)
+
+            val merge = ctx match {
+              case TransformationContext.ForTotal(_)             => mergeTotal(optionalTo)
+              case TransformationContext.ForPartial(_, failFast) => mergePartial(optionalTo, failFast)
+            }
+
+            (ctx.config.flags.optionFallbackMerge match {
+              case None =>
+                srcToResult
+              case Some(dsls.SourceOrElseFallback) =>
+                srcToResult.parMap2(fallbackToResult)((srcTo, fallbackTo) => fallbackTo.foldLeft(srcTo)(merge))
+              case Some(dsls.FallbackOrElseSource) =>
+                srcToResult.parMap2(fallbackToResult)((srcTo, fallbackTo) => fallbackTo.foldRight(srcTo)(merge))
+            }).flatMap(DerivationResult.expanded(_))
+          }
         case _ =>
           DerivationResult.attemptNextRule
       }
@@ -33,7 +52,7 @@ private[compiletime] trait TransformOptionToOptionRuleModule {
         optionalTo: OptionalValue[To, InnerTo]
     )(implicit
         ctx: TransformationContext[From, To]
-    ): DerivationResult[Rule.ExpansionResult[To]] =
+    ): DerivationResult[TransformationExpr[To]] =
       ExprPromise
         .promise[InnerFrom](ExprPromise.NameGenerationStrategy.FromType)
         .traverse { (newFromExpr: Expr[InnerFrom]) =>
@@ -50,7 +69,7 @@ private[compiletime] trait TransformOptionToOptionRuleModule {
             // We're constructing:
             // ${ src }.fold[$To](None, innerFrom: $InnerFrom => Some(${ innerFrom }))
             // but working with every OptionalValue
-            DerivationResult.expandedTotal(
+            DerivationResult.totalExpr(
               optionalFrom.fold[To](
                 ctx.src,
                 optionalTo.empty,
@@ -63,7 +82,7 @@ private[compiletime] trait TransformOptionToOptionRuleModule {
             //   ${ derivedResultInnerTo }.map(Option(_))
             // }
             // but working with every OptionalValue
-            DerivationResult.expandedPartial(
+            DerivationResult.partialExpr(
               optionalFrom.fold[partial.Result[To]](
                 ctx.src,
                 ChimneyExpr.PartialResult.Value(optionalTo.empty).upcastToExprOf[partial.Result[To]],
@@ -78,5 +97,46 @@ private[compiletime] trait TransformOptionToOptionRuleModule {
             )
           }
         }
+
+    private def mapFallbackOptions[From, To, InnerTo: Type](optionalTo: OptionalValue[To, InnerTo])(implicit
+        ctx: TransformationContext[From, To]
+    ): DerivationResult[Vector[TransformationExpr[To]]] = ctx.config.filterCurrentOverridesForFallbacks.view
+      .map { case TransformerOverride.Fallback(fallback) =>
+        import fallback.{Underlying as Fallback, value as fallbackExpr}
+        Type[Fallback] match {
+          case OptionalValue(fallback2) =>
+            import fallback2.{Underlying as InnerFallback, value as optionalFallback}
+            implicit val fallbackCtx: TransformationContext[Fallback, To] =
+              ctx.updateFromTo[Fallback, To](fallbackExpr, updateFallbacks = _ => Vector.empty)(Fallback, ctx.To)
+            Some(mapOptions[Fallback, To, InnerFallback, InnerTo](optionalFallback, optionalTo))
+          case _ => None
+        }
+      }
+      .collect { case Some(result) => result }
+      .toVector
+      .sequence
+
+    private def mergeTotal[To, InnerTo](
+        optionalTo: OptionalValue[To, InnerTo]
+    ): (TransformationExpr[To], TransformationExpr[To]) => TransformationExpr[To] =
+      (texpr1, texpt2) => TransformationExpr.fromTotal(optionalTo.orElse(texpr1.ensureTotal, texpt2.ensureTotal))
+
+    private def mergePartial[To: Type, InnerTo](
+        optionalTo: OptionalValue[To, InnerTo],
+        failFast: Expr[Boolean]
+    ): (TransformationExpr[To], TransformationExpr[To]) => TransformationExpr[To] = {
+      case (TransformationExpr.TotalExpr(expr1), TransformationExpr.TotalExpr(expr2)) =>
+        TransformationExpr.fromTotal(optionalTo.orElse(expr1, expr2))
+      case (texpr1, texpr2) =>
+        TransformationExpr.fromPartial(
+          ChimneyExpr.PartialResult.map2(
+            texpr1.ensurePartial,
+            texpr2.ensurePartial,
+            Expr.Function2.instance(optionalTo.orElse(_, _)),
+            failFast
+          )
+        )
+    }
+
   }
 }

chimney/src/main/scala/io/scalaland/chimney/internal/compiletime/derivation/transformer/rules/TransformToOptionRuleModule.scala

@@ -30,5 +30,16 @@ private[compiletime] trait TransformToOptionRuleModule { this: Derivation & Tran
   ): DerivationResult[Rule.ExpansionResult[To]] =
     // We're constructing:
     // '{ ${ derivedTo2 } /* created from Option(src) */  }
-    TransformOptionToOptionRule.expand(ctx.updateFromTo[Option[From], To](Expr.Option(ctx.src)))
+    TransformOptionToOptionRule.expand(
+      ctx.updateFromTo[Option[From], To](Expr.Option(ctx.src), updateFallbacks = wrapFallbacks)
+    )
+
+  private val wrapFallbacks: TransformerOverride.ForFallback => Vector[TransformerOverride.ForFallback] = {
+    case fb @ TransformerOverride.Fallback(fallback) =>
+      import fallback.{Underlying as Fallback, value as fallbackExpr}
+      Vector(Type[Fallback] match {
+        case OptionalValue(_) => fb
+        case _                => TransformerOverride.Fallback(Expr.Option(fallbackExpr).as_??)
+      })
+  }
 }