Optional non-empty fields in patched class overwritten by empty optional fields of patcher

[AlifCor]

Consider the following:

case class User(name: Option[String], age: Option[Int])

case class UserPatch(name: Option[String], age: Option[Int])

val user = User(Some("John"), Some(30))
val userPatch = UserPatch(None, None)

user.patchWith(userPatch) == user //expected behaviour, but *false* 
user.patchWith(userPatch) == User(None, None) //true

I would expect that, if the optional fields of the patchers are empty and those of the patched class are not, the latter ones should remain. Is the current behaviour the expected one ?

[krzemin]

Considering current implementation, this is expected behavior. If the types of corresponding fields are the same, value from the patch is taken.

However there is some support for the optional fields in the patch. Considering you have a field of type T in the object and Option[T] in the patch, the value from the patch is taken only, when it's defined.

It can be demonstrated with slight modification of your example:

case class User2(name: String, age: Int)

> val user2 = User2("John", 30)
user2: User2 = User2("John", 30)

> user2.patchWith(UserPatch(None, None)) == user2
res: Boolean = true

Or even other way around, wrapping patch fields in Option:

case class UserPatch2(name: Option[Option[String]], age: Option[Option[Int]])

> user.patchWith(UserPatch2(None, None)) == user
res: Boolean = true

[AlifCor]

However there is some support for the optional fields in the patch. Considering you have a field of type T in the object and Option[T] in the patch, the value from the patch is taken only, when it's defined.

Do you think it would make sense to extend that support to the case I demonstrated ? Namely, you have a field of type Option[T] and Option[T] in the patch, and have the value from the patch taken only if it's defined.

[krzemin]

Well, both semantics may have perfect sense in different contexts. I think it makes sense to support also your use case under a flag. Would you like to craft a PR?

[AlifCor]

Thanks, I'll take a look once I have some time.

[lloydmeta]

I just ran into this one, and thought I could get away with defining a local Patcher[Option[A], Option[A]] that incorporates fallback-like semantics, but no go. I guess the macro for generating Patchers doesn't search for implicits?

@ import $ivy.{`io.scalaland::chimney:0.3.0`}
import $ivy.$

@ import io.scalaland.chimney.dsl._
import io.scalaland.chimney.dsl._

@ import io.scalaland.chimney._
import io.scalaland.chimney._

@ implicit def optionFallbackPatcher[A] = new Patcher[Option[A], Option[A]] {
    def patch(o: Option[A], patch: Option[A]): Option[A] = o.orElse(patch)
  }
defined function optionFallbackPatcher

@ final case class Data(o: Option[Int])
defined class Data

@ Data(Some(1)).patchWith(Data(None)) // would have expected res5 = Data(Some(1))
res5: Data = Data(None)

[krzemin]

Discussion on the same topic continued in #123.

[krzemin]

Resolved in #131.
@lloydmeta you're right that current patchers macro doesn't look for implicits. I created new issue (#133) which aims to resolve it.