我现在正在学习Scala，有一点Haskell的经验。有一件让我感到奇怪的事情是：在Scala中，所有函数参数必须带类型注解，而这在Haskell中并不需要。为什么会这样呢？试着给出一个更具体的例子：一个加法函数的写法如下：
def add(x:Double, y:Double) = x + y
但是，这仅适用于双精度浮点数（好吧，整数也可以，因为存在隐式类型转换）。但是如果您想定义自己的类型，该类型定义了自己的 + 运算符，那该怎么办呢？如何编写一个函数，使其适用于定义了 + 运算符的任何类型？
Haskell使用Hindley-Milner类型推导算法，而Scala为了支持面向对象的一面，不得不暂时放弃使用它。
为了轻松编写适用于所有适用类型的添加函数，您需要使用Scala 2.8.0：
Welcome to Scala version 2.8.0.r18189-b20090702020221 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_15).
Type in expressions to have them evaluated.
Type :help for more information.
scala> import Numeric._
import Numeric._
scala> def add[A](x: A, y: A)(implicit numeric: Numeric[A]): A =
| numeric.plus(x, y)
add: [A](x: A,y: A)(implicit numeric: Numeric[A])A
scala> add(1, 2)
res0: Int = 3
scala> add(1.1, 2.2)
res1: Double = 3.3000000000000003
scala> abstract class Addable[T]{
| def +(x: T, y: T): T
| }
defined class Addable
scala> def add[T](x: T, y: T)(implicit addy: Addable[T]): T =
| addy.+(x, y)
add: [T](T,T)(implicit Addable[T])T
这类似于Haskell中的类型类。然后，要将此通用类实现为特定类型，您需要编写以下内容（这里是Int、Double和String的示例）：
scala> implicit object IntAddable extends Addable[Int]{
| def +(x: Int, y: Int): Int = x + y
| }
defined module IntAddable
scala> implicit object DoubleAddable extends Addable[Double]{
| def +(x: Double, y: Double): Double = x + y
| }
defined module DoubleAddable
scala> implicit object StringAddable extends Addable[String]{
| def +(x: String, y: String): String = x concat y
| }
defined module StringAddable
此时，您可以使用所有三种类型调用add函数：
scala> add(1,2)
res0: Int = 3
scala> add(1.0, 2.0)
res1: Double = 3.0
scala> add("abc", "def")
res2: java.lang.String = abcdef
Addable[T]的特质，该特质声明了+运算符，则可以将通用添加函数编写为：def add[T <: Addable[T]](x : T, y : T) = x + y
这限制了add函数只能应用于实现了Addable trait的类型T。
不幸的是，当前Scala库中没有这样的trait。但是你可以看一下类似情况下的处理方式，比如Ordered[T] trait。这个trait声明了比较运算符，并被RichInt、RichFloat等类进行混合。然后你可以编写一个sort函数，它可以接受一个List[T]，其中[T <: Ordered[T]]来对混合了ordered trait的元素列表进行排序。由于隐式类型转换，比如Float到RichFloat，你甚至可以在Int、Float或Double列表上使用你的sort函数。
正如我所说，不幸的是，没有对应于+运算符的trait。因此，你需要自己编写所有内容。你需要编写Addable[T] trait，创建AddableInt、AddableFloat等类，它们扩展Int、Float等并混合Addable trait，最后添加隐式转换函数，将Int转换为AddableInt等，以便编译器可以实例化并使用你的add函数。
这个函数本身将会非常简单：
def add(x: T, y: T): T = ...
def +(x: T, y: T): T = ...
然而，还有一个缺失的部分，那就是类型参数本身。按照现在的写法，该方法缺少其类。最有可能的情况是您正在调用T实例上的+方法，并将另一个T实例传递给它。我最近也这样做了，定义了一个特质，其中说：“加性群由加操作和反转元素的手段组成”
trait GroupAdditive[G] extends Structure[G] {
def +(that: G): G
def unary_- : G
}
class Real private (s: LargeInteger, err: LargeInteger, exp: Int) extends Number[Real] with Field[Real] with Ordered[Real] {
...
def +(that: Real): Real = { ... }
...
}
这可能比你现在想知道的更多，但它确实展示了如何定义通用参数以及如何实现它们。
最终，具体类型并不是必需的，但编译器至少需要知道类型边界。