Typeclass 从 shapeless-guide 的泛型推导

Question

鉴于优秀shapeless-guide的以下内容：

package net

import shapeless.labelled.FieldType
import shapeless._

sealed trait JsonValue
case class JsonObject(fields: List[(String, JsonValue)]) extends JsonValue
case class JsonArray(items: List[JsonValue])             extends JsonValue
case class JsonString(value: String)                     extends JsonValue
case class JsonNumber(value: Double)                     extends JsonValue
case class JsonBoolean(value: Boolean)                   extends JsonValue
case object JsonNull                                     extends JsonValue

这本书展示了如何编写通用 JsonEncoder，即给定一个 A，提供 A:

的 JSON 表示

trait JsonEncoder[A] {
  def encode(value: A): JsonValue
}
object JsonEncoder {

  def apply[A](implicit ev: JsonEncoder[A]): JsonEncoder[A] =
    ev

  def instance[A](f: A => JsonValue): JsonEncoder[A] =
    new JsonEncoder[A] {
      override def encode(x: A): JsonValue = f(x)
    }

  implicit val doubleEncoder: JsonEncoder[Double] =
    instance[Double](JsonNumber)

  implicit val stringEncoder: JsonEncoder[String] =
    instance[String](JsonString)

  implicit val boolEncoder: JsonEncoder[Boolean] =
    instance[Boolean](JsonBoolean)

  implicit def optionEncoder[A](implicit ev: JsonEncoder[A]): JsonEncoder[Option[A]] =
    instance[Option[A]] {
      case Some(a) => ev.encode(a)
      case None    => JsonNull
    }

  implicit def listEncoder[A](implicit ev: JsonEncoder[A]): JsonEncoder[List[A]] =
    instance[List[A]]( list => JsonArray(list.map(ev.encode)))

  trait JsonObjectEncoder[A] extends JsonEncoder[A] {
    def encode(value: A): JsonObject
  }

  def createObjectEncoder[A](fn: A => JsonObject): JsonObjectEncoder[A] =
    new JsonObjectEncoder[A] {
      override def encode(value: A): JsonObject = fn(value)
    }

  implicit val hnilEncoder: JsonObjectEncoder[HNil] =
    createObjectEncoder(hnil => JsonObject(Nil))

  implicit def hlistObjectEncoder[K <: Symbol, H, T <: HList](
    implicit
     witness: Witness.Aux[K],
     hEncoder: Lazy[JsonEncoder[H]],
     tEncoder: JsonObjectEncoder[T]
  ): JsonObjectEncoder[FieldType[K, H] :: T] =
    createObjectEncoder { hlist =>
      val fieldName = witness.value.name
      val head      = hEncoder.value.encode(hlist.head)
      val tail      = tEncoder.encode(hlist.tail)
      JsonObject( (fieldName, head) :: tail.fields )
  }

  implicit def genericObjectEncoder[A, H <: HList](
    implicit
    generic: LabelledGeneric.Aux[A, H],
    hEncoder: Lazy[JsonObjectEncoder[H]]
  ): JsonEncoder[A] =
    createObjectEncoder { value =>
      hEncoder.value.encode(  generic.to(value) )
    }

据我了解，上面的代码通常会导出 case class 的 JsonEncoder。但是，它不会处理 sealed trait 或 Coproduct:

import net.JsonEncoder

case class A(name: String, age: Double)

scala> JsonEncoder[A]
res0: net.JsonEncoder[A] = net.JsonEncoder$$anon@6b974139

sealed trait Parent
case class Kid() extends Parent

scala> JsonEncoder[Parent]
<console>:14: error: could not find implicit value for parameter ev: net.JsonEncoder[Parent]
       JsonEncoder[Parent]
                  ^

import shapeless._

type Co = Kid :+: CNil

scala> JsonEncoder[Co]
<console>:20: error: could not find implicit value for parameter ev: net.JsonEncoder[Co]
       JsonEncoder[Co]
                  ^

然后，本文提供了以下代码，据我所知，一般派生出 JsonEncoder 的 JsonEncoder 实例：

 implicit val cnilObjectEncoder: JsonObjectEncoder[CNil] =
    createObjectEncoder(cnil => throw new Exception("Inconceivable!"))

  implicit def coproductObjectEncoder[K <: Symbol, H, T <: Coproduct](
     implicit
     witness: Witness.Aux[K],
     hEncoder: Lazy[JsonEncoder[H]],
     tEncoder: JsonObjectEncoder[T]
   ): JsonObjectEncoder[FieldType[K, H] :+: T] = {
    val typeName = witness.value.name
    createObjectEncoder {
      case Inl(h) =>
        JsonObject(List(typeName -> hEncoder.value.encode(h)))

      case Inr(t) =>
        tEncoder.encode(t)
    }
  }

但是，从 REPL 中，我仍然无法得出 sealed trait 或余积：

import net.JsonEncoder

scala> sealed trait Parent
defined trait Parent
case class Kid() extends Parent

scala> JsonEncoder[Parent]
<console>:14: error: could not find implicit value for parameter ev: net.JsonEncoder[Parent]
       JsonEncoder[Parent]
                  ^

import shapeless._

type Co = Kid :+: CNil

scala> JsonEncoder[Co]
<console>:17: error: could not find implicit value for parameter ev: net.JsonEncoder[Co]
       JsonEncoder[Co]
                  ^

为什么这两个实例，即 Parent 和 Co，不是派生的？

Answer 1

您应该删除 genericObjectEncoder 的类型参数 H 的上限。如果将它限制为 HList 的子类型，则排除了它实际上是 Coproduct.

的情况

implicit def genericObjectEncoder[A, H](
  implicit
  generic: LabelledGeneric.Aux[A, H],
  hEncoder: Lazy[JsonObjectEncoder[H]]
): JsonEncoder[A] =
  createObjectEncoder { value =>
    hEncoder.value.encode(  generic.to(value) )
  }

现在你可以看到它起作用了。

scala> sealed trait Parent; case class Kid() extends Parent
defined trait Parent
defined class Kid

scala> JsonEncoder[Parent]
res0: JsonEncoder[Parent] = JsonEncoder$$anon@127aef0a

Typeclass 从 shapeless-guide 的泛型推导

Generic Derivation of Typeclass from shapeless-guide

scala

shapeless