scala - 在 Scala 中构建类型类的不同方法？

Question

取自 Programming Scala 书中的类型类示例:

case class Address(street: String, city: String)
case class Person(name: String, address: Address)

trait ToJSON {
  def toJSON(level: Int = 0): String

  val INDENTATION = "  "
  def indentation(level: Int = 0): (String,String) = 
    (INDENTATION * level, INDENTATION * (level+1))
}

implicit class AddressToJSON(address: Address) extends ToJSON {
  def toJSON(level: Int = 0): String = {
    val (outdent, indent) = indentation(level)
    s"""{
      |${indent}"street": "${address.street}", 
      |${indent}"city":   "${address.city}"
      |$outdent}""".stripMargin
  }
}

implicit class PersonToJSON(person: Person) extends ToJSON {
  def toJSON(level: Int = 0): String = {
    val (outdent, indent) = indentation(level)
    s"""{
      |${indent}"name":    "${person.name}", 
      |${indent}"address": ${person.address.toJSON(level + 1)} 
      |$outdent}""".stripMargin
  }
}

val a = Address("1 Scala Lane", "Anytown")
val p = Person("Buck Trends", a)

println(a.toJSON())
println()
println(p.toJSON())

代码工作正常，但我的印象(来自一些博客文章)类型类通常在 scala 中以这种方式完成:

// src/main/scala/progscala2/implicits/toJSON-type-class.sc

case class Address(street: String, city: String)
case class Person(name: String, address: Address)

trait ToJSON[A] {
  def toJSON(a: A, level: Int = 0): String

  val INDENTATION = "  "
  def indentation(level: Int = 0): (String,String) =
    (INDENTATION * level, INDENTATION * (level+1))
}

object ToJSON {
  implicit def addressToJson: ToJSON[Address] = new ToJSON[Address] {
    override def toJSON(address: Address, level: Int = 0) : String = {
          val (outdent, indent) = indentation(level)
          s"""{
              |${indent}"street": "${address.street}",
              |${indent}"city":   "${address.city}"
              |$outdent}""".stripMargin
    }
  }
  implicit def personToJson: ToJSON[Person] = new ToJSON[Person] {
    override def toJSON(a: Person, level: Int): String = {
          val (outdent, indent) = indentation(level)
          s"""{
              |${indent}"name":    "${a.name}",
              |${indent}"address": ${implicitly[ToJSON[Address]].toJSON(a.address, level + 1)}
              |$outdent}""".stripMargin
    }
  }
  def toJSON[A](a: A, level: Int = 0)(implicit ev: ToJSON[A]) = {
    ev.toJSON(a, level)
  }
}


val a = Address("1 Scala Lane", "Anytown")
val p = Person("Buck Trends", a)


import ToJSON.toJSON
println(toJSON(a))
println(toJSON(p))

哪种方式更好或更正确？欢迎任何见解。

Answer 1

调用第一个 ToJSON 有点牵强完全是“类型类”(尽管这些术语并不是标准化的，甚至您的第二个更符合 Scala 惯用语的版本在许多重要方面也与 Haskell 中的类型类不同)。

我认为定义的类型类的属性之一是它们允许您约束泛型类型。 Scala 以上下文边界的形式提供了特殊的语法来支持这一点，所以我可以编写例如以下:

import io.circe.Encoder

def foo[A: Numeric: Encoder](a: A) = ...

这限制了类型 A拥有两个 Numeric和 Encoder实例。

此语法不适用于第一个 ToJSON ，并且您必须使用诸如 View 边界(现已弃用)或隐式隐式转换参数之类的东西。

还有很多种操作是第一个 ToJSON无法提供的风格。例如，假设我们有一个 Monoid使用类型类的标准 Scala 编码:

trait Monoid[A] {
  def empty: A
  def plus(x: A, y: A): A
}

我们想把它翻译成第一个样式，我们有一个未参数化的 Monoid trait 将成为我们希望能够视为 monoidal 的类型的隐式转换的目标。我们完全不走运，因为我们没有可以引用我们的 empty 的类型参数。和 plus签名。

另一个论点:标准库中的类型类( Ordering 、 CanBuildFrom 等)都使用第二种样式，您会遇到的绝大多数第三方 Scala 库也是如此。

简而言之，永远不要使用第一个版本。只有当您只有 A => Whatever 形式的操作时，它才会起作用。 (对于一些具体的 Whatever )，没有很好的语法支持，并且通常不被社区认为是惯用的。