在类型类的实现中使用 HList.foldRight 如何查找隐式？

Question

我是使用 Shapeless 的新手，我正在尝试使用 Shapeless 自动生成类型类和折叠 HList。 我的目标是使用 scalaz.Show 的类型类实现将HList 呈现为(a, b, c, d)

我的第一步是使用以下代码在 REPL 中进行实验

import shapeless._
import shapeless.ops.hlist._

object prettyPrint extends Poly2 {
  implicit def defaultCase[A] = at((a:A, z:String)=>s", ${a.toString}$z")
}

def print[H, T<:HList](f: H :: T)(implicit folder:RightFolder.Aux[H :: T, String, prettyPrint.type, String]) = {
  f.foldRight("")(prettyPrint)
}

val f = 1::'a::2::'b::HNil
val res = s"(${f.head}${print(f.tail)})" // Results res: String = (1, 'a, 2, 'b)

在此之后，我在LabelledTypeClassCompanion[...] 的实现中实现了以下方法。不幸的是，这段代码无法编译，因为编译器抱怨缺少隐式，即使我不知道 REPL 中的代码和下面的代码之间有什么区别。我的问题是下面代码中的问题是什么，我该如何解决？

def showFold[H, T<:HList](f: H::T)(implicit folder:RightFolder.Aux[ H::T, String, prettyPrint.type, String]) = {
  f.foldRight("")(prettyPrint)
}

override def product[H, T <: HList](name: String, ch: ScalazShow[H], ct: ScalazShow[T]): ScalazShow[H :: T] = {
  new ScalazShow[H :: T] {
    override def shows(ft: (H :: T)): String = {
     showFold(ft) // This does not compile
    }

  }
}

错误：(49, 18) 找不到参数文件夹的隐式值：shapeless.ops.hlist.RightFolder.Aux[shapeless.::[H,T],String,com.fpinscala.ninetynine.prettyPrint.type ，细绳] showFold(ft) // 这不会编译

下面是完整的实现

package com.fpinscala.ninetynine

import shapeless._
import shapeless.ops.hlist.RightFolder

import scalaz.{Show => ScalazShow}

object prettyPrint extends Poly2 {
  implicit def defaultCase[A]:this.Case.Aux[A, String, String] = at[A, String]{
    (a,z) => s", $a$z"
  }
}


object ShowImpl extends LabelledTypeClassCompanion[ScalazShow] {

  implicit def symbolShow : ScalazShow[Symbol] = new ScalazShow[Symbol] {
    override def shows(f: Symbol): String = f.toString()
  }

  implicit def intShow : ScalazShow[Int] = new ScalazShow[Int] {
    override def shows(f: Int): String = f.toString
  }

  override val typeClass: LabelledTypeClass[ScalazShow] = new LabelledTypeClass[ScalazShow] {

    override def coproduct[L, R <: Coproduct](name: String, cl: => ScalazShow[L], cr: => ScalazShow[R]): ScalazShow[L :+: R] = new ScalazShow[L :+: R] {
      override def shows(lr: (L :+: R)): String = lr match {
        case Inl(l) => cl.shows(l)
        case Inr(r) => cr.shows(r)
      }
    }

    override def emptyCoproduct: ScalazShow[CNil] = new ScalazShow[CNil] {
      override def shows(f: CNil): String = ""
    }


    def showFold[H, T<:HList](f: H::T)(implicit folder:RightFolder.Aux[ H::T, String, prettyPrint.type, String]) = {
      f.foldRight("")(prettyPrint)
    }

    override def product[H, T <: HList](name: String, ch: ScalazShow[H], ct: ScalazShow[T]): ScalazShow[H :: T] = {
      new ScalazShow[H :: T] {
        override def shows(ft: (H :: T)): String = {
         showFold(ft) // This does not compile 
        }

      }
    }

    override def project[F, G](instance: => ScalazShow[G], to: (F) => G, from: (G) => F): ScalazShow[F] = new ScalazShow[F] {
      override def shows(f: F): String = instance.shows(to(f))
    }

    override def emptyProduct: ScalazShow[HNil] = new ScalazShow[HNil] {
      override def shows(f: HNil): String = ""
    }

  }
}

Answer 1

您可以将类型类约束视为一种将有关类型的一些信息从具体上下文传递到通用上下文（通过调用堆栈向后移动）的方式。在这种情况下，如果您想以这种方式编写实现，您实际上确实需要 RightFolder 实例，但是 LabelledTypeClass 中的方法签名不允许您携带该信息，所以您不走运（不过，基本的想法是可能的——你只需要稍微不同的方法。

更新

我刚刚意识到我误读了您的问题——因为您使用的是 TypeClass 类型类，我假设您想要案例类和密封特征层次结构以及 hlist 和副产品的实例。我的回答给了你所有这些（就像TypeClass 一样），所以你可以这样写：

scala> (123 :: "abc" :: HNil).shows
res2: String = (123, abc)

以及我在下面给出的案例类和密封特征示例。如果您不想要案例类和密封特征，您可以删除 genericShow 定义。

为什么具体上下文和通用上下文之间存在差异

这是一个更简单的案例。假设我们想使用Show 将一个值打印两次。我们可以这样做：

scala> import scalaz._, Scalaz._
import scalaz._
import Scalaz._

scala> val x: Int = 123
x: Int = 123

scala> s"${ x.shows }${ x.shows }"
res0: String = 123123

这里x 有一个具体类型，当我们在它上面调用.shows 时，编译器会尝试为那个具体类型找到一个Show 的实例。 Scalaz 提供了一个Show[Int]，所以一切正常，我们得到了我们想要的结果。

接下来我们可以尝试编写一个通用版本：

def toStringTwice[X](x: X): String = s"${ x.shows }${ x.shows }"

但是编译器会报错：

<console>:18: error: value shows is not a member of type parameter X
       def toStringTwice[X](x: X): String = s"${ x.shows }${ x.shows }"
                                                               ^

这是因为编译器无法证明X 有一个Show 实例，因为它根本不知道X。你可以写一堆重载的具体方法：

scala> def toStringTwice(x: String): String = s"${ x.shows }${ x.shows }"
toStringTwice: (x: String)String

scala> def toStringTwice(x: Int): String = s"${ x.shows }${ x.shows }"
toStringTwice: (x: Int)String

...

但这正是类型类旨在为您省去的那种烦人的样板。您可以通过为编译器提供所需的尽可能多的信息来抽象它们，而不是枚举您拥有 Show 实例的所有类型：

scala> def toStringTwice[X: Show](x: X): String = s"${ x.shows }${ x.shows }"
toStringTwice: [X](x: X)(implicit evidence$1: scalaz.Show[X])String

现在您可以使用 Int 或其他任何具有 Show 实例的名称来调用它：

scala> toStringTwice(123)
res2: String = 123123

你不能做的是用另一个不受约束的泛型类型来调用它：

def toStringFourTimes[X](x: X): String = s"${ toStringTwice(x) * 2 }"

相反，您必须再次添加约束：

scala> def toStringFourTimes[X: Show](x: X): String = s"${ toStringTwice(x) * 2 }"
toStringFourTimes: [X](x: X)(implicit evidence$1: scalaz.Show[X])String

等等——你必须一直使用Show 约束，直到你得到一个具体的类型。您只能通过两种方式使用toStringTwice：在具有Show 实例的具体类型上，或在具有Show 约束的泛型类型上。

请注意，以上都不是 Shapeless 特定的——这只是类型类的工作方式。

一种可能的解决方法

不幸的是，在我看来，这似乎不是 LabelledTypeClass 的一个很好的用例，因为所需的实例并不真正适合构建 TypeClass 类型类支持的实例的方式。你可能会这样做，但我真的不想尝试。

你的prettyPrint 的工作方式也存在问题——它实际上并没有使用Show 实例A（甚至没有一个可以使用），而是调用了可怕的通用toString。

下面是我可能会如何写这个的快速初稿：

import scalaz.Show, scalaz.Scalaz._
import shapeless._
import shapeless.ops.coproduct.Folder
import shapeless.ops.hlist.RightReducer

object prettyPrint2 extends Poly2 {
  implicit def defaultCase[A: Show]: Case.Aux[A, String, String] =
    at[A, String]((a, z) => s"$a, $z")
}

object prettyPrint extends Poly1 {
  implicit def defaultCase[A: Show]: Case.Aux[A, String] = at[A](_.shows)
}

implicit def hlistShow[L <: HList](implicit
  reducer: RightReducer.Aux[L, prettyPrint2.type, String]
): Show[L] = Show.shows(l => "(" + l.reduceRight(prettyPrint2) + ")")

implicit def coproductShow[C <: Coproduct](implicit
  folder: Folder.Aux[prettyPrint.type, C, String]
): Show[C] = Show.shows(_.fold(prettyPrint))

implicit def genericShow[A, R](implicit
  gen: Generic.Aux[A, R],
  reprShow: Show[R]
): Show[A] = reprShow.contramap(gen.to)

然后：

scala> Foo(123, "abc").shows
res0: String = (123, abc)

scala> (Foo(123, "abc"): Base).shows
res1: String = (123, abc)

您可能会遇到涉及嵌套案例类等的极端案例，这些案例由于编译器错误而无法正常工作（有关一些详细信息，请参阅我的 slides here 关于 Scala 中的泛型派生），但这种方法或多或少应该能起到什么作用你想要的。