如何在Scala中定义支持所有可计算数据类型的泛型函数？

核心解决方案：使用类型类（Type Class） #

Scala的数值类型（如Int、Long、Float）都是final类，无法直接扩展自定义特质，因此类型类是解决这类重复代码问题的标准方案——它通过「隐式实例」实现ad-hoc多态，无需修改原有类型即可为其赋予新的行为约束。

方法1：利用Scala标准库的Numeric类型类 #

Scala标准库已经内置了Numeric类型类，封装了数值类型的基本运算（+、-、*、比较等），直接复用即可：

// 泛型square函数，支持所有实现了Numeric的类型
def square[T: Numeric](n: T): T = {
  val numeric = implicitly[Numeric[T]]
  numeric.times(n, n)
}

// 调用示例
square(5)          // Int类型，返回25
square(10L)        // Long类型，返回100L
square(3.14f)      // Float类型，返回约9.8596f
square(BigInt(7))  // BigInt类型，返回49

T: Numeric是上下文绑定语法，等价于要求存在一个隐式的Numeric[T]实例，标准库已经为所有常用数值类型（Int、Long、Float、Double、BigInt、BigDecimal等）提供了默认实例。

如果需要更复杂的运算，Numeric也提供了对应的方法：

def add[T: Numeric](a: T, b: T): T = implicitly[Numeric[T]].plus(a, b)
def isLessThan[T: Numeric](a: T, b: T): Boolean = implicitly[Numeric[T]].lt(a, b)

方法2：自定义类型类（针对特殊需求） #

如果标准库的Numeric不能满足定制化需求，可以自己定义类型类：

1. 定义类型类特质，声明需要的运算：

trait Computable[T] {
  def multiply(a: T, b: T): T
  def add(a: T, b: T): T
  def lessThan(a: T, b: T): Boolean
  // 按需添加其他运算
}

2. 为目标数值类型实现隐式实例：

object Computable {
  // Int的实例
  implicit val intComputable: Computable[Int] = new Computable[Int] {
    override def multiply(a: Int, b: Int): Int = a * b
    override def add(a: Int, b: Int): Int = a + b
    override def lessThan(a: Int, b: Int): Boolean = a < b
  }

  // Long的实例
  implicit val longComputable: Computable[Long] = new Computable[Long] {
    override def multiply(a: Long, b: Long): Long = a * b
    override def add(a: Long, b: Long): Long = a + b
    override def lessThan(a: Long, b: Long): Boolean = a < b
  }

  // 其他类型如Float、BigInt同理
}

3. 定义泛型函数使用该类型类：

import Computable._

def square[T: Computable](n: T): T = implicitly[Computable[T]].multiply(n, n)
def sumAndCompare[T: Computable](a: T, b: T): Boolean = {
  val comp = implicitly[Computable[T]]
  comp.lessThan(comp.add(a, b), comp.multiply(a, b))
}

为什么之前的尝试不可行？ #

• 直接用T :> AnyVal泛型：AnyVal包含Boolean、Unit等不支持数值运算的类型，编译器无法确保n * n是合法操作，因此报错。
• 让Int等扩展自定义特质：Scala的基本数值类型（Int、Long、Byte等）都是final类，语言规则不允许继承扩展，因此无法通过这种方式约束类型。

内容的提问来源于stack exchange，提问作者Michael W.