HList.foldRight 在类型 class 的实现中使用时如何查找隐式？
How does HList.foldRight look for implicits when used in the implementation of a type class?
我是使用 Shapeless 的新手，我正在尝试使用 Shapeless 自动生成 class 类型并折叠 HList。
我的目标是使用 scalaz.Show
的类型 class 实现将 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,String]
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 = ""
}
}
}
您可以将类型 class 约束视为一种将有关类型的一些信息从具体上下文传递到通用上下文（通过调用堆栈向后移动）的方法。在这种情况下，如果您想以这种方式编写实现，您实际上确实需要那个 RightFolder 实例，但是 LabelledTypeClass 中的方法签名不允许您传递该信息，所以您运气不好（虽然基本的想法是可行的——你只需要稍微不同的方法）。
更新
我刚刚意识到我稍微误解了你的问题——因为你使用的是 TypeClass 类型 class 我假设你想要 case classes 的实例和密封的特征层次结构以及hlists 和副产品。我的回答给了你所有这些（就像 TypeClass 一样），所以你可以这样写：
scala> (123 :: "abc" :: HNil).shows
res2: String = (123, abc)
以及我在下面给出的案例 class 和密封特征示例。如果你不想要 case classes 和 sealed traits 你可以删除 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
...
但这正是类型 classes 旨在让您摆脱的烦人样板。您可以通过为编译器提供所需的信息来抽象它们，而不是枚举您拥有 Show 个实例的所有类型：
scala> def toStringTwice[X: Show](x: X): String = s"${ x.shows }${ x.shows }"
toStringTwice: [X](x: X)(implicit evidence: 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: scalaz.Show[X])String
依此类推 — 您必须一直执行 Show 约束，直到获得具体类型。您只能以两种方式使用 toStringTwice：在具有 Show 实例的具体类型上，或在具有 Show 约束的泛型类型上。
请注意，上面的 none 是特定于 Shapeless 的——这只是类型 class 的工作方式。
一个可能的修复
不幸的是，在我看来，这并不是 LabelledTypeClass 的一个很好的用例，因为所需的实例并不真正适合 TypeClass 类型 class支持。你也许可以做到，但我真的不想尝试。
你的 prettyPrint 的工作方式也有一个问题——它实际上并没有使用 A 的 Show 实例（甚至没有一个可以使用），而是调用可怕的宇宙 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)
您可能 运行 涉及嵌套案例 classes 等角落案例，这些案例由于编译器错误而无法正常工作（请参阅我的 slides here 关于 Scala 中的泛型推导一些细节），但这种方法应该或多或少地做你想做的。
我是使用 Shapeless 的新手，我正在尝试使用 Shapeless 自动生成 class 类型并折叠 HList。 我的目标是使用 scalaz.Show
的类型 class 实现将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,String] 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 = ""
}
}
}
您可以将类型 class 约束视为一种将有关类型的一些信息从具体上下文传递到通用上下文（通过调用堆栈向后移动）的方法。在这种情况下，如果您想以这种方式编写实现，您实际上确实需要那个 RightFolder 实例，但是 LabelledTypeClass 中的方法签名不允许您传递该信息，所以您运气不好（虽然基本的想法是可行的——你只需要稍微不同的方法）。
更新
我刚刚意识到我稍微误解了你的问题——因为你使用的是 TypeClass 类型 class 我假设你想要 case classes 的实例和密封的特征层次结构以及hlists 和副产品。我的回答给了你所有这些（就像 TypeClass 一样），所以你可以这样写：
scala> (123 :: "abc" :: HNil).shows
res2: String = (123, abc)
以及我在下面给出的案例 class 和密封特征示例。如果你不想要 case classes 和 sealed traits 你可以删除 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
...
但这正是类型 classes 旨在让您摆脱的烦人样板。您可以通过为编译器提供所需的信息来抽象它们，而不是枚举您拥有 Show 个实例的所有类型：
scala> def toStringTwice[X: Show](x: X): String = s"${ x.shows }${ x.shows }"
toStringTwice: [X](x: X)(implicit evidence: 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: scalaz.Show[X])String
依此类推 — 您必须一直执行 Show 约束，直到获得具体类型。您只能以两种方式使用 toStringTwice：在具有 Show 实例的具体类型上，或在具有 Show 约束的泛型类型上。
请注意，上面的 none 是特定于 Shapeless 的——这只是类型 class 的工作方式。
一个可能的修复
不幸的是，在我看来，这并不是 LabelledTypeClass 的一个很好的用例，因为所需的实例并不真正适合 TypeClass 类型 class支持。你也许可以做到，但我真的不想尝试。
你的 prettyPrint 的工作方式也有一个问题——它实际上并没有使用 A 的 Show 实例（甚至没有一个可以使用），而是调用可怕的宇宙 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)
您可能 运行 涉及嵌套案例 classes 等角落案例，这些案例由于编译器错误而无法正常工作（请参阅我的 slides here 关于 Scala 中的泛型推导一些细节），但这种方法应该或多或少地做你想做的。