Scala 中没有 arguments 的“隐式 def”有什么用？

Question

看到了这段代码，不知道怎么用。 我了解到implicit def用于隐式转换，它带有一个参数，以便它可以将其参数转换为另一种类型。 请帮助解释下面隐式的用法，任何示例都很棒。 先感谢您！

  implicit def eitherWrites[A: Writes, B: Writes] = Writes[Either[A, B]]({
    case Left(a) => implicitly[Writes[A]].writes(a)
    case Right(b) => implicitly[Writes[B]].writes(b)
  })

Answer 1

语法A: Writes在eitherWrites的类型参数中称为上下文绑定。

def foo[T: C]

是语法糖

def foo[T](implicit evidence: C[T])

换句话说： eitherWrites没有一个而是两个（隐式）参数，因为它是语法糖

implicit def eitherWrites[A, B](
  implicit evidence`1: Writes[A], 
           evidence`2: Writes[B]
) = Writes[Either[A, B]]({
  case Left(a) => implicitly[Writes[A]].writes(a)
  case Right(b) => implicitly[Writes[B]].writes(b)
})

Answer 2

我可以向您展示一个不同的示例，以了解在您的情况下如何使用implicit def ：

  // a Haskell-like type class that provides textual representation
  trait Show[T] {
    def show(x: T): String
  }

  object Show {

    def show[T: Show](x: T): String = implicitly[Show[T]].show(x)

    implicit val showString: Show[String] = identity(_)
    implicit val showInt: Show[Int]       = _.toString

    implicit def showTup[T: Show, U: Show]: Show[(T, U)] =
      tup => s"(${Show.show[T](tup._1)}, ${Show.show[U](tup._2)})"
  }

implicit def称为类型 class 派生或隐式派生。 基本上，它使您能够根据当前现有的隐式参数和描述如何自动组合它们的隐式转换来创建新类型 class。

接下来的 3 行是等效的：

  println(Show.show(123, "abc"))                  // (abc, 123)
  println(Show.show((123, "abc")))                // (abc, 123)
  println(Show.show(123 -> "abc"))                // (abc, 123)

注意这里的参数是 2 个元素的元组，因为show需要一个参数。 在这种情况下，编译器插入一个带有 2 个隐式参数的隐式转换。 脱糖代码为：

  println(Show.show(123, "abc")(showTup(showInt, showString)))

你也可以这样做：

println(Show.show((123, "abc"), (123, "abc")))  // ((123, abc), (123, abc))

弄清楚编译器如何翻译它有点棘手，但一般规则仍然存在：隐式参数插入在普通参数之后，在单独的参数列表中。 脱糖代码为：

  println(
    Show.show((123, "abc"), (123, "abc"))(
      showTup(showTup(showInt, showString), showTup(showInt, showString))
    )
  )

如果您自己无法弄清楚，请使用-Xprint:typer选项运行您的代码，然后scalac编译器将向您显示在类型检查器添加了所有隐式转换后您的代码的样子。

起初这看起来很奇怪，但一旦你弄清楚，它实际上是非常有限的，因为它只适用于 2 个元素的元组。 因此，例如，如果您想要一个包含 3 个元素的元组，则必须编写另一个带有 3 个上下文边界的implicit def ，依此类推。 您的示例表现出类似的行为。