Scala：避免在不同匹配情况下多次执行相同操作的最佳方法

Question

我想在表的一行中找到所有值的最小值（可能有空值，列可能是不同的类型——Int、Long、Double、Boolean）。

函数的返回类型取决于输入列，如果都是 Int 则返回类型应该是 Int。如果混合不同类型，则加倍，等等。

我知道 returnType 是什么。

方法如下：

 def findMin(args: List[Any]): Any =

一种可能的解决方案是：

returnType match {
  case IntType =>
     minValInt = Int.Min
     for(args){
        check for not null 
        for(arg <- args) {
          temp: Int  = arg match {
             case x: Int => x
             case x: Boolean => convert to Int              
          }
        minValInt = min(minValInt, temp)
        return minValInt

  case LongType =>
     minValLong = Long.Min
     for(args){
       check for not null -> minValLong = min(minValLong, arg) (some restrictions while using the arg value directly)
     }
     return minValLong

  case DoubleType =>
     minValDouble = Double.Min
     for(arg <- args){
       check for not null 
       temp: Double = arg match {
          case x: Int => convert to double 
          case x: Long => convert to double (some restrictions while converting)
          case x: Double => x
          case x: Boolean => convert to double
       }
       minValDouble = min(minValDouble, temp)
     }
     return minValDouble
}

这可以在单个匹配情况下完成还是更好的“更整洁”？

Answer 1

大概是这样的吧？

list.flatMap(x => Option(x)).minBy { 
   case n: Number => n.doubleValue
   case true => 1.0
   case false => 0.0
}(Ordering.Double)

Answer 2

除了我对用例缺乏想象力之外，您已经在您的问题中将函数类型定义为 List [Any] -> Any。

因此，您实际上没有告诉编译器会发生什么，并失去了拥有静态类型系统的优势。

请注意，使用静态类型的函数式编程是关于定义输入域并在编译时将其映射到输出域。 因此，返回 Int 的函数与返回 Long 的函数或返回 Double 的函数不同。因此，要么它们是不同的函数，要么将输出域定义为所有可能返回类型的公共超类型，从而在途中丢失特定信息。

关于显示的代码，返回类型似乎是 Int、Long、Double 中的任何一种，具体取决于返回最小值所需的最大精度。

由于 Int 适合 Long 并且都适合 Double，为什么不将 Double 声明为保证的最大精度返回类型？

因此该函数将是 List[Any] -> Double 类型，从而使程序的其余部分在编译时特定于类型安全？