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

Question

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

我的第一步是使用以下代码在 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 = ""
    }

  }
}

Answer 1

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

更新

我刚刚意识到我稍微误读了您的问题——因为您使用的是 TypeClass type class 我假设您想要 case 类和密封特征层次结构以及 hlists 和 coproducts 的实例。我的回答为您提供了所有这些(就像 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)

您可能会遇到涉及嵌套 case 类等的极端情况，这些情况由于编译器错误而不起作用(有关详细信息，请参阅我的 slides here 关于 Scala 中的泛型派生)，但这种方法或多或少应该可以满足您的需求。