将一个case class 递归地转换为另一个结构相同的case class

Question

将一个case class 递归地转换为另一个结构相同的case class

4

我正在尝试使用Shapeless将类似下面这样的案例类进行转换：

case class A(int: Int, str: String)
case class B(a: A, str: String)

case class AnotherA(int: Int, str: String)
case class AnotherB(a: AnotherA, str: String)

使用 Generic，我可以轻松地在 A 和 AnotherA 之间进行转换，但是对于 B 和 AnotherB，由于（当然）a 成员的类型不同，无法进行转换。

我认为可以将 case class 转换为嵌套的 HList，参照此示例，但是如何将嵌套的 HList 转换回 case class，或者有更简单的方法可以实现吗？

- Chikei

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- devkat · Accepted Answer

这里是一个可能的实现，DeepHUnlister 会递归地替换泛型表示中嵌套的子 HList，并用它们各自的 case class 实例进行替换。

trait DeepHUnlister[L <: HList, R <: HList] extends (L => R)

object DeepHUnlister {

  implicit object hnil extends DeepHUnlister[HNil, HNil] {
    def apply(r: HNil) = HNil
  }

  implicit def headList[H <: HList, T <: HList, HR <: HList, TR <: HList, A](
    implicit
      gen: Generic.Aux[A, HR],
      dhh: Lazy[DeepHUnlister[H, HR]],
      dht: Lazy[DeepHUnlister[T, TR]]):
        DeepHUnlister[H :: T, A :: TR] =
    new DeepHUnlister[H :: T, A :: TR] {
      def apply(r: H :: T) = gen.from(dhh.value(r.head)) :: dht.value(r.tail)
    }

  implicit def headAtomic[H, T <: HList, TR <: HList](
    implicit dht: Lazy[DeepHUnlister[T, TR]]):
      DeepHUnlister[H :: T, H :: TR] =
    new DeepHUnlister[H :: T, H :: TR] {
      def apply(r: H :: T) = r.head :: dht.value(r.tail)
    }

  def apply[T <: HList, R <: HList](implicit du: DeepHUnlister[T, R]):
    DeepHUnlister[T, R] = du

}

例子：

case class A(int: Int, str: String)
case class B(a: A, str: String)
case class C(b: B, d: Double)

case class A1(int: Int, str: String)
case class B1(a: A1, str: String)
case class C1(a: B1, d: Double)

type ARepr = Int :: String :: HNil
type BRepr = ARepr :: String :: HNil
type CRepr = BRepr :: Double :: HNil

val c = C(B(A(1, "a"), "b"), 1.0)

val lister = DeepHLister[C :: HNil]
val repr = lister(c :: HNil)
println(repr)

val unlister = DeepHUnlister[CRepr :: HNil, C1 :: HNil]
val c1 = unlister(repr).head
// c1 = C1(B1(A1(1,a),b),1.0)

也许可以改进这个解决方案，避免将表示类型作为参数传递给取消列表器。

更新

这是一种省略源类型但需要强制转换的版本:

trait DepInvFn1[T] {
  type In
  def apply(i: In): T
}

trait DeepHUnlister[R <: HList] extends DepInvFn1[R] { type In <: HList }

trait DeepHUnlisterLP {

  type Aux[L <: HList, R <: HList] = DeepHUnlister[R] { type In = L }

  implicit def headAtomic[H, TR <: HList](
    implicit dt: Lazy[DeepHUnlister[TR]]):
      Aux[H :: dt.value.In, H :: TR] =
    new DeepHUnlister[H :: TR] {
      type In = H :: dt.value.In
      def apply(r: H :: dt.value.In) = r.head :: dt.value(r.tail)
    }

}

object DeepHUnlister extends DeepHUnlisterLP {

  implicit object hnil extends DeepHUnlister[HNil] {
    type In = HNil
    def apply(r: HNil) = HNil
  }

  implicit def headList[HR <: HList, TR <: HList, A](
    implicit
      gen: Generic.Aux[A, HR],
      dh: Lazy[DeepHUnlister[HR]],
      dt: Lazy[DeepHUnlister[TR]]):
        Aux[dh.value.In :: dt.value.In, A :: TR] =
    new DeepHUnlister[A :: TR] {
      type In = dh.value.In :: dt.value.In
      def apply(r: dh.value.In :: dt.value.In) = gen.from(dh.value(r.head)) :: dt.value(r.tail)
    }

  def apply[R <: HList](implicit du: DeepHUnlister[R]): DeepHUnlister[R] = du

}

使用方法：

val unlister = DeepHUnlister[C1 :: HNil]
val c1 = unlister(repr.asInstanceOf[unlister.In]).head
// c1 = C1(B1(A1(1,a),b),1.0)