无形转换案例类到HList并跳过所有选项字段

Question

我有下一堂课：

case class Foo(a: Option[Int], b: Option[String], c: Option[Double])

正如您所看到的，所有字段都是可选的，我希望将此类转换为HList或Tuple，就像

val f1 = Foo(Some(1) , None, Some(3D))
val f2 = Foo(None, "foo")

val result1 = f1.to[Int::Double::HNil] // => 1::3D
val result2 = f2.to[String::HNil] // "foo"

没有反思可能吗？

Answer 1

有可能使用Shapeless中的现有类型类（类似于NatTRel和RemoveAll ）来执行此操作，但我不是百分之百确定，并且这是我只编写自己的类型类的情况：

import shapeless._

trait OptionalPieces[L <: HList, S <: HList] {
  def apply(l: L): Option[S]
}

object OptionalPieces extends LowPriorityOptionalPieces {
  implicit val hnilOptionalPieces: OptionalPieces[HNil, HNil] =
    new OptionalPieces[HNil, HNil] {
      def apply(l: HNil): Option[HNil] = Some(HNil)
    }

  implicit def hconsOptionalPiecesMatch[H, T <: HList, S <: HList](implicit
    opt: OptionalPieces[T, S]
  ): OptionalPieces[Option[H] :: T, H :: S] =
    new OptionalPieces[Option[H] :: T, H :: S] {
      def apply(l: Option[H] :: T): Option[H :: S] = for {
        h <- l.head
        t <- opt(l.tail)
      } yield h :: t
    }
}

sealed class LowPriorityOptionalPieces {
  implicit def hconsOptionalPiecesNoMatch[H, T <: HList, S <: HList](implicit
    opt: OptionalPieces[T, S]
  ): OptionalPieces[Option[H] :: T, S] =
    new OptionalPieces[Option[H] :: T, S] {
      def apply(l: Option[H] :: T): Option[S] = opt(l.tail)
    }
}

这证明了L 至少包含了Option包含的S所有元素，并且为您提供了一种在运行时（安全地）解包它们的方法。

然后我们可以定义一个语法助手类，如下所示：

implicit class OptionalPiecesSyntax[A, R <: HList](a: A)(implicit
  gen: Generic.Aux[A, R]
) {
  def to[S <: HList](implicit op: OptionalPieces[gen.Repr, S]): Option[S] =
    op(gen.to(a))
}

然后：

scala> val f1 = Foo(Some(1) , None, Some(3D))
f1: Foo = Foo(Some(1),None,Some(3.0))

scala> val f2 = Foo(None, Some("foo"), None)
f2: Foo = Foo(None,Some(foo),None)

scala> val result1 = f1.to[Int :: Double :: HNil]
result1: Option[shapeless.::[Int,shapeless.::[Double,shapeless.HNil]]] = Some(1 :: 3.0 :: HNil)

scala> val result2 = f2.to[String :: HNil]
result2: Option[shapeless.::[String,shapeless.HNil]] = Some(foo :: HNil)

如果你真的想要异常，你可以在语法类中调用.get ，但这似乎是一个坏主意。