Безопасное копирование полей между классами дел разных типов

Предполагая, что у вас есть классы дел, подобные следующему

case class Test1(a:String,b:Int,c:Char)

case class Test2(a:String,b:Int)

И вы создаете экземпляры классов со следующими переменными

val test1 = Test1("first",2,'3')

val test2 = Test2("1st",20)

Есть ли способ использовать .copy метод (или иным образом), чтобы применить переменные внутри Test2 к Test1, что-то вроде

val test3 = test1.copy(test2) //Note this isn't valid scala code
// Result should be ("1st",20,'3')

Если это невозможно в чистом scala, как это будет сделано в Shapeless 1/2 (текущий код находится в Shapeless 1, однако мы планируем перейти на Shapeless 2 в какой-то момент времени)

Источник

2 ответа

Решение

В бесформенном 2.0.0 это можно сделать примерно так:

scala> import shapeless._
import shapeless._

scala> case class Test1(a: String, b: Int, c: Char)
defined class Test1

scala> case class Test2(a: String, b: Int)
defined class Test2

scala> val test1 = Test1("first", 2, '3')
test1: Test1 = Test1(first,2,3)

scala> val test2 = Test2("1st", 20)
test2: Test2 = Test2(1st,20)

scala> val test1Gen = Generic[Test1]
test1Gen: ... = $1$$1@6aac621f

scala> val test2Gen = Generic[Test2]
test2Gen: ... = $1$$1@5aa4954c

scala> val test3 = test1Gen.from(test2Gen.to(test2) :+ test1.c)
test3: Test1 = Test1(1st,20,3)

Обратите внимание, что здесь делаются предположения о порядке полей в каждом из классов дел, а не используются сведения о метках полей. Это может быть подвержено ошибкам, когда у вас есть несколько полей одного типа: типы могут выстраиваться в линию, но скрытая семантика может быть изменена.

Мы можем исправить это с помощью бесформенного LabelledGeneric, LabelledGeneric отображает значения класса case в бесформенные расширяемые записи, которые, наряду с захватом типов значений полей, также кодируют имена полей в типе с помощью одноэлементного типа соответствующего Scala Symbol, С небольшой дополнительной инфраструктурой (которую я скоро добавлю к бесформенной версии 2.1.0) это позволяет нам безопасно отображать классы дел с минимальным количеством шаблонов,

import shapeless._, record._, syntax.singleton._, ops.hlist.Remove

/**
 * This will be in shapeless 2.1.0 ...
 *
 * Permute the elements of the supplied `HList` of type `L` into the same order
 * as the elements of the `HList` of type `M`.
 */
trait Align[L <: HList, M <: HList] extends (L => M) {
  def apply(l: L): M
}

object Align {
  def apply[L <: HList, M <: HList]
    (implicit alm: Align[L, M]): Align[L, M] = alm

  implicit val hnilAlign: Align[HNil, HNil] = new Align[HNil, HNil] {
    def apply(l: HNil): HNil = l
  }

  implicit def hlistAlign[L <: HList, MH, MT <: HList, R <: HList]
    (implicit
      select: Remove.Aux[L, MH, (MH, R)],
      alignTail: Align[R, MT]): Align[L, MH :: MT] = new Align[L, MH :: MT] {
    def apply(l: L): MH :: MT = {
      val (h, t) = l.removeElem[MH]
      h :: alignTail(t)
    }
  }
}

/**
 * This, or something like it, will be in shapeless 2.1.0 ...
 *
 * Utility trait intended for inferring a field type from a sample value and
 * unpacking it into its key and value types.
 */
trait Field {
  type K
  type V
  type F = FieldType[K, V]
}

object Field {
  def apply[K0, V0](sample: FieldType[K0, V0]) =
    new Field { type K = K0; type V = V0 }
}

object OldWineNewBottle {
  case class From(s1: String, s2: String)
  case class To(s2: String, i: Int, s1: String)

  val from = From("foo", "bar")

  val fromGen = LabelledGeneric[From]
  val toGen = LabelledGeneric[To]

  // Define the type of the i field by example
  val iField = Field('i ->> 0)

  val align = Align[iField.F :: fromGen.Repr, toGen.Repr]

  // extend the fields of From with a field for 'i', permute into
  // the correct order for To and create a new instance ...
  val to = toGen.from(align('i ->> 23 :: fromGen.to(from)))

  assert(to == To("bar", 23, "foo"))
}
Источник

+1 к бесформенности

Скопируйте объект класса случая Scala в другой класс дела с дополнительным полем в конце:

        import shapeless._
  import syntax.singleton._
  case class A(a: Int, b: Int, c: Int, d: Int, e: Int)
  case class B(a: Int, b: Int, c: Int, d: Int, e: Int, z: Int)
  val agen = LabelledGeneric[A]
  val bgen = LabelledGeneric[B]
  val a = A(1, 2, 3, 4, 5)
  val b = bgen.from(agen.to(a) :+ ('z ->> 999))

Скопируйте объект класса случая Scala в другой объект класса случая с дополнительным полем в начале:

        import shapeless._
  import syntax.singleton._
  case class A(a: Int, b: Int, c: Int, d: Int, e: Int)
  case class B(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int, d: Int, e: Int)
  val agen = LabelledGeneric[A]
  val bgen = LabelledGeneric[B]
  val a = A(1, 2, 3, 4, 5)
  val b = bgen.from(('x ->> 777) +: ('y ->> 888) +: ('z ->> 999) +: agen.to(a))

По сути, это лучший способ, который я вижу на данный момент, чтобы избежать перечисления всех полей в

      B.apply(A a) { a = a.a; b = a.b, c = a.c, etc… }
Источник
Другие вопросы по тегам