Scalanie dwóch klas przypadków w Scala, ale z głęboko zagnieżdżonych typów, bez obiektywu boilerplate

Question

podobne do this case class question ale z niespodzianką:

Mam klasy przypadek, który ma pewne głęboko zagnieżdżonych klas sprawę jako właściwości. Jako prosty przykład

case class Foo(fooPropA:Option[String], fooPropB:Option[Int]) 
case class Bar(barPropA:String, barPropB:Int) 
case class FooBar(name:Option[String], foo:Foo, optionFoo: Option[Foo], bar:Option[Bar]) 

Chciałbym połączyć dwie klasy przypadków foobar razem, przyjmując wartości, które istnieją dla wejścia i stosując je do istniejącej instancji, tworząc uaktualnioną wersję:

val fb1 = FooBar(Some("one"), Foo(Some("propA"), None), Some(Foo(Some("propA"), Some(3))), Some(Bar("propA", 4))) 
val fb2 = FooBar(None, Foo(Some("updated"), Some(2)), Some(Foo(Some("baz"), None)), None) 
val merged = fb1.merge(fb2) 
//merged = FooBar(Some("one"), Foo(Some("updated"), Some(2)), Some(Foo(Some("baz"), Some(3))), Some(Bar("propA", 4))) 

Wiem, że mogę użyć soczewki, aby skomponować głęboko zagnieżdżone aktualizacje nieruchomości; jednak czuję, że będzie to wymagało wiele kodu płyty kotła: potrzebuję soczewki dla każdej własności i innego złożonego obiektywu w klasie rodzica. Wydaje się, że to dużo do utrzymania, nawet jeśli używa się bardziej zwięzłego podejścia do tworzenia soczewek w shapeless.

Najtrudniejszą częścią jest element optionFoo: w tym scenariuszu oba elementy istnieją z Some (value). Jednak chciałbym scalić właściwości opcji wewnętrznej, a nie tylko nadpisać fb1 nowymi wartościami fb2.

Zastanawiam się, czy istnieje dobre podejście do łączenia tych dwóch wartości w sposób, który wymaga minimalnego kodu. Moje odczucia mówią, żebym spróbował użyć metody unapply w klasie sprawy, aby zwrócić krotkę, powtórzyć i połączyć krotki w nową krotkę, a następnie zastosować krotkę z powrotem do klasy sprawy.

Czy jest to skuteczniejszy sposób na zrobienie tego?

Answer 1

Jednym z prostych sposobów rozwiązania tego problemu jest myślenie o operacji scalania jako czegoś takiego, jak dodanie, biorąc pod uwagę odpowiedni zestaw instancji monoid. Możesz zobaczyć moją odpowiedź here na rozwiązanie bardzo podobnego problemu, ale rozwiązanie jest teraz jeszcze łatwiejsze dzięki the efforts z zespołu typelevel. Pierwszy dla klas przypadków:

case class Foo(fooPropA: Option[String], fooPropB: Option[Int]) 
case class Bar(barPropA: String, barPropB: Int) 
case class FooBar(name: Option[String], foo: Foo, bar: Option[Bar]) 

Wtedy niektórzy boilerplate (co nie będzie konieczne w nadchodzącym wydaniu 2.0 bezkształtną):

import shapeless._ 

implicit def fooIso = Iso.hlist(Foo.apply _, Foo.unapply _) 
implicit def barIso = Iso.hlist(Bar.apply _, Bar.unapply _) 
implicit def fooBarIso = Iso.hlist(FooBar.apply _, FooBar.unapply _) 

mam zamiar oszukać trochę dla jasności i umieścić „drugi” monoid instancję dla Option w zakresie zamiast używać znaczników:

import scalaz._, Scalaz._ 
import shapeless.contrib.scalaz._ 

implicit def optionSecondMonoid[A] = new Monoid[Option[A]] { 
    val zero = None 
    def append(a: Option[A], b: => Option[A]) = b orElse a 
} 

i skończymy:

scala> val fb1 = FooBar(Some("1"), Foo(Some("A"), None), Some(Bar("A", 4))) 
fb1: FooBar = FooBar(Some(one),Foo(Some(propA),None),Some(Bar(propA,4))) 

scala> val fb2 = FooBar(None, Foo(Some("updated"), Some(2)), None) 
fb2: FooBar = FooBar(None,Foo(Some(updated),Some(2)),None) 

scala> fb1 |+| fb2 
res0: FooBar = FooBar(Some(1),Foo(Some(updated),Some(2)),Some(Bar(A,4))) 

Aby uzyskać dodatkową dyskusję, zobacz stronę my previous answer.

Answer 2

Moja poprzednia odpowiedź wykorzystana Shapeless 1.2.4, Scalaz i shapeless-contrib oraz Shapeless 1.2.4 i shapeless-contrib są dość przestarzałe w tym momencie (ponad dwa lata później), więc oto zaktualizowana odpowiedź za pomocą Shapeless 2.2 .5 i cats 0.3.0. Będę zakładać konfigurację kompilacji tak:

scalaVersion := "2.11.7" 

libraryDependencies ++= Seq(
    "com.chuusai" %% "shapeless" % "2.2.5", 
    "org.spire-math" %% "cats" % "0.3.0" 
) 

Shapeless obejmuje obecnie klasę ProductTypeClass typu że możemy użyć tutaj.W końcu projekt Milesa Sina z kittens (lub coś podobnego) prawdopodobnie zapewni tego rodzaju rzeczy dla klas typu kota (podobnie jak w roli, którą shapeless-contrib grał dla Scalaza), ale na razie użycie tylko ProductTypeClass nie jest złe:

import algebra.Monoid, cats.std.all._, shapeless._ 

object caseClassMonoids extends ProductTypeClassCompanion[Monoid] { 
    object typeClass extends ProductTypeClass[Monoid] { 
    def product[H, T <: HList](ch: Monoid[H], ct: Monoid[T]): Monoid[H :: T] = 
     new Monoid[H :: T] { 
     def empty: H :: T = ch.empty :: ct.empty 
     def combine(x: H :: T, y: H :: T): H :: T = 
     ch.combine(x.head, y.head) :: ct.combine(x.tail, y.tail) 
     } 

    val emptyProduct: Monoid[HNil] = new Monoid[HNil] { 
     def empty: HNil = HNil 
     def combine(x: HNil, y: HNil): HNil = HNil 
    } 

    def project[F, G](inst: => Monoid[G], to: F => G, from: G => F): Monoid[F] = 
     new Monoid[F] { 
     def empty: F = from(inst.empty) 
     def combine(x: F, y: F): F = from(inst.combine(to(x), to(y))) 
     } 
    } 
} 

A potem:

import cats.syntax.semigroup._ 
import caseClassMonoids._ 

case class Foo(fooPropA: Option[String], fooPropB: Option[Int]) 
case class Bar(barPropA: String, barPropB: Int) 
case class FooBar(name: Option[String], foo: Foo, bar: Option[Bar]) 

I wreszcie:

scala> val fb1 = FooBar(Some("1"), Foo(Some("A"), None), Some(Bar("A", 4))) 
fb1: FooBar = FooBar(Some(1),Foo(Some(A),None),Some(Bar(A,4))) 

scala> val fb2 = FooBar(None, Foo(Some("updated"), Some(2)), None) 
fb2: FooBar = FooBar(None,Foo(Some(updated),Some(2)),None) 

scala> fb1 |+| fb2 
res0: FooBar = FooBar(Some(1),Foo(Some(Aupdated),Some(2)),Some(Bar(A,4))) 

Zauważ, że ten łączy w sobie wartości wewnątrz Some, co nie jest dokładnie tym, o co pyta, ale jest wspomniane przez OP w komentarzu do mojej drugiej odpowiedzi. Jeśli chcesz zastąpić zachowanie, możesz zdefiniować odpowiednią Monoid[Option[A]], tak jak w mojej drugiej odpowiedzi.

Answer 3

Korzystanie Kittens 1.0.0-M8, jesteśmy teraz w stanie czerpać Semigroup (myślałem, że to wystarczy do tego przykładu, ale Monoid jest po prostu importować away) bez boilerplate w ogóle:

import cats.implicits._ 
import cats.derived._, semigroup._, legacy._ 

case class Foo(fooPropA: Option[String], fooPropB: Option[Int]) 
case class Bar(barPropA: String, barPropB: Int) 
case class FooBar(name: Option[String], foo: Foo, bar: Option[Bar]) 

val fb1 = FooBar(Some("1"), Foo(Some("A"), None), Some(Bar("A", 4))) 

val fb2 = FooBar(None, Foo(Some("updated"), Some(2)), None) 
println(fb1 |+| fb2) 

Wynik:

FooBar(Some(1),Foo(Some(Aupdated),Some(2)),Some(Bar(A,4)))