给定 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中的定义？

请您参考如下方法:

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可以使用这些不同的实例，结果非常不同，并且没有编译时或运行时错误。