hlist.foldright如何在实现类型类的实现中寻找隐性

Question

我是新手使用无形的新手，并且我正在尝试无形的自动类型类别的生成和折叠hlists。我的目标是使用Scalaz.Show.show

的TypeClass实现将HList作为CC_1渲染。

我的第一步是使用以下代码在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[...]时实现了以下方法。不幸的是，此代码不会编译，因为编译器抱怨丢失隐含的内容，即使我无法分辨替补中的代码与下面的代码之间有什么区别。我的问题是下面的代码中有什么问题，我该如何解决？

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.hlist.rightfolder.aux [shapeless。，细绳] 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类型类，我以为您想要您的案例类和密封特质层次结构以及HLISTS和HLISTS和COCRODUCTS的实例。我的答案给了您所有这些(就像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

等等 - 您必须一直沿着(a, b, c, d)0约束，直到您拥有混凝土类型。您只能以两种方式使用toStringTwice：在具有Show实例的混凝土类型上，或在具有Show约束的通用类型上。

请注意，以上都不是无形的特定特异性 - 这只是类型类的工作方式。

一种可能的修复

不幸的是，在我看来，对于LabelledTypeClass来说，这似乎并不是一个很好的用例，因为所需的实例实际上并不适合构建TypeClass类型类支持的实例。您可能可以做到，但我真的不想尝试。

您的prettyPrint的工作方式也存在一个问题 - 实际上它不是使用Show的CC_27实例(甚至没有一个可以使用(，而是在调用可怕的Universal 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)

您可能会遇到涉及嵌套的案例类等的角案例。想要。