Scala 中的多态方法——为什么允许这样做？

Question

我在 Scala 中有以下多态方法：

  def addTwoThings[S](item1:S, item2:S) =
  {
    item1 + " | " + item2
  }

尽管我已经指定 item1 和 item2 应该是同一类型 "S"，但以下内容编译得很好。我需要用隐含证据做些什么吗？

明确地说，我实际上希望编译器抱怨它们不是同一类型，但它似乎允许我继续，这让我感到困惑。谢谢

println(addTwoThings("1",2))

Answer 1

又是Scala编译器类型推断的问题

你必须给出明确的类型来引导编译器

addTwoThings[String]("1",2)

以上会报编译错误

您的代码有效的原因

String和Int的共同超类型是Any。所以 Scala 编译器假设函数中的 S 为 Any

scala> def addTwoThings[S](item1:S, item2:S) =
     |   {
     |     item1 + " | " + item2
     |   }
addTwoThings: [S](item1: S, item2: S)String

scala> println(addTwoThings("1",2))
1 | 2

scala> println(addTwoThings[String]("1",2))
<console>:22: error: type mismatch;
 found   : Int(2)
 required: String
       println(addTwoThings[String]("1",2))

Answer 2

您在不明确使用 .toString 的情况下获得 + 运算符的原因在此处描述：What Scala feature allows the plus operator to be used on Any?。 Predef 中的这些附加隐式是 scala 中许多问题的根源，但很难摆脱这种遗留问题。

为了找出 addTwoThings("1",2) 起作用的原因 - 让我们重写它以获得 S 的精确推断：

scala> def addTwoThings[S](item1:S, item2:S): S = item1
addTwoThings: [S](item1: S, item2: S)S

scala> addTwoThings(1, "1")
res5: Any = 1

您可以注意到类型 S = Any 被推断为常见类型。

所以，这里有几个解决方案：

1) 如果你可以在你的方法签名中允许两个类型参数，这里是解决方案：

def addTwoThings[S1, S2](item1:S1, item2:S2)(implicit ev: S1 =:= S2, ev2: S2 =:= S1) = {
    item1 + " | " + item2
}

注意：ev2 对于检查来说可能是多余的，但它提供了更完整的相等性，请参阅

实验：

scala> addTwoThings(1, "1")
<console>:18: error: Cannot prove that Int =:= String.
              addTwoThings(1, "1")
                          ^

scala> addTwoThings("2", "1")
res11: String = 2 | 1

2) 或者您可以使用 Evidence that types are not equal in Scala :

排除 Any/AnyRef（所有内容的通用超类型）

trait =:!=[A, B]
implicit def neq[A, B] : A =:!= B = new =:!=[A, B] {}
implicit def neqAmbig1[A] : A =:!= A = ???
implicit def neqAmbig2[A] : A =:!= A = ???

def addTwoThings[S](item1:S, item2:S)(implicit ev: S =:!= Any, ev2: S =:!= AnyRef): S = item1

实验：

scala> addTwoThings(1, "1")
<console>:18: error: ambiguous implicit values:
 both method neqAmbig1 of type [A]=> =:!=[A,A]
 and method neqAmbig2 of type [A]=> =:!=[A,A]
 match expected type =:!=[Any,Any]
              addTwoThings(1, "1")
                          ^

scala> addTwoThings(1, 1)
res7: Int = 1

注意：此方法不需要精确的类型相等，因此如果 B1 <: B2 - addTwoThings(b1, b2) - 仍然有效。它仅保护您免受不相关的类型层次结构（这可能很有用）的影响。实际上 != Any 没有 != AnyRef 不会在 object A; object B; addTwoThings(B, A) 上给你错误。

注意 2：编译器提供的错误很难读，更多信息在这里 - How can I customize Scala ambiguous implicit errors when using shapeless type inequalities

3) 另一种方法是柯里化：

def addTwoThings[S](item1:S)(item2:S) = ""

实验：

scala> addTwoThings(1)(1)
res8: String = ""

scala> addTwoThings(1)("1")
<console>:18: error: type mismatch;
 found   : String("1")
 required: Int
              addTwoThings(1)("1")
                              ^

类型推断不会寻找柯里化参数的公共超类型（您可以阅读更多here）

Scala 中的多态方法——为什么允许这样做？

Polymorphic Methods in Scala- why is this allowed?

polymorphism

types

scala

type-inference