scala - Haskell v. Scala 中的类型类

Question

给定 f 的以下实现在 Haskell 和 Scala 中:

Prelude> let f x y = x == y
Prelude> :t f
f :: Eq a => a -> a -> Bool

斯卡拉:

scala> trait Equal[A] { def ===(x: A, y: A): Boolean }
defined trait Equal

scala> implicit val equalsInt = new Equal[Int] {
     |  def ===(x: Int, y: Int):Boolean = (x == y)
     | }
equalsInt: Equal[Int] = $anon$1@3daa422a

scala> def f[A : Equal](x: A, y: A): Boolean = 
     |   implicitly[Equal[A]].===(x, y)
f: [A](x: A, y: A)(implicit evidence$1: Equal[A])Boolean

scala> f(10, 20)
res0: Boolean = false

scala> f(55, 55)
res1: Boolean = true

观看此视频，Typeclasses v. the World ，我的不完全理解是 Scala 的隐式解析，即它如何实现类型类，容易受到不正确/不一致的隐式解析的影响。但是，Haskell 不使用类型类的隐式，所以在 Haskell 中不存在这样的问题。

考虑到 Scala 和 Haskell 的 typeclass 实现之间的差异，以上 f 可能出现的问题是什么？ Haskell中没有的Scala中的定义？

Answer 1

Scala 版本可能会遇到 Haskell 版本无法解决的一个问题，那就是在 Scala 中，您可以定义多个 Equal[Int] 的实例。当隐式解析机制试图找到一个实例时在范围内。什么时候会出现如下错误:

<console>:12: error: ambiguous implicit values:
 both value EqualInt1 of type => Equal[Int]
 and value EqualInt2 of type => Equal[Int]
 match expected type Equal[Int]
              f(1, 2)
               ^

更新。正如 Carl 在评论中指出的那样，另一个问题是您可以在代码中的不同点在范围内拥有不同的实例，以便调用 f可以使用这些不同的实例，结果非常不同，并且没有编译时或运行时错误。