scala – 在不同类型的案例类之间安全地复制字段

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",'3')
test1: Test1 = Test1(first,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,3)

请注意,这会假设每个案例类中的字段顺序,而不是使用字段标签信息.如果您有多个相同类型的字段,这可能会出错：类型可能会排成一行,但潜在的语义可能会被更改.

我们可以通过使用无形的LabelledGeneric来解决这个问题. LabelledGeneric将case类值映射到无形可扩展记录,这些记录除了捕获字段值的类型外,还通过相应Scala符号的单例类型对类型中的字段名称进行编码.通过一些额外的基础设施(我将很快添加到无形的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,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"))
}