添加依赖于类型类的有效性检查（可选隐式）

Question

在 scala 中，我们可以使用隐式类型类根据参数化类型的参数有条件地将方法添加到该类型上。例如，Iterator.sum：

def sum[B >: A](implicit num: Numeric[B]): B = foldLeft(num.zero)(num.plus)

必须有 Numeric 类型类的实例才能调用此方法：到目前为止

scala> List(1, 2, 3).sum
res0: Int = 6

scala> List("a", "b").sum
<console>:6: error: could not find implicit value for parameter num: Numeric[java.lang.String]
       List("a", "b").sum
                  ^

，一切顺利。假设我想要某种集合类型，My2Col：

class My2Col[A](a1 : A, a2 : A)

但我想强制执行，如果这是用 A : Numeric 制作的， 然后 a2 > a1 。但是，使用非数字的 A 来创建它完全有效。

My2Col("a", "b") //OK
My2Col("b", "a") //OK
My2Col(1, 2)     //OK
My2Col(2, 1)     //THROW IllegalArgumentException

有人对我如何做到这一点有任何想法吗？

PS。如果有人对更好的问题标题有任何建议，我会洗耳恭听

Answer 1

class My2Col[A](a1 : A, a2 : A)(implicit num: Numeric[A] = null){
  for{check <- Option(num); if(check.gteq(a1, a2))}
     throw new IllegalArgumentException
}

Answer 2

我将通过创建 2 个表示需求的隐式来实现这一点，一个更通用（对于除 Int 或 Numeric[T] 之外的所有类型），另一个更通用更具体（对于 Int 或 Numeric[T]）。

然后，按照隐式解析的规则，我会将更具体的一个放在 Requirement 类型的伴生对象中，将更通用的一个放在伴生对象的基类中。这样我可以确保编译器首先尝试应用更具体的。

当然，缺点是如果用户显式提供隐式参数，则可以绕过此机制而不进行检查。

像这样的东西（其中 Int 是具有特定规则的类型，Foo 是集合类）：

  package ex                                                                                                          

  trait Requirement[T] {                                                                                            
    def check(a1: T, a2: T): Unit                                                                                   
  }                                                                                                                 

  trait BaseReq {                                                                                                   
    implicit def genericReq[T] = new Requirement[T] {                                                               
      def check(a1: T, a2: T) {println("generic")}                                                                  
    }                                                                                                               
  }                                                                                                                 

  object Requirement extends BaseReq {                                                                              
    implicit object IntReq extends Requirement[Int] {                                                               
      def check(a1: Int, a2: Int) = {                                                                               
        println("int")                                                                                              
        if (a2 <= a1) throw new IllegalArgumentException                                                            
      }                                                                                                             
    }                                                                                                               
  }                                                                                                                 

  class Foo[T](a1: T, a2: T)(implicit req: Requirement[T]) {                                                        
    req.check(a1, a2)                                                                                               

    // whatever `foo` does follows                                                                                  
  }                                                                                                            

  object Main {                                                                                                     
    def main(args: Array[String]) {                                                                                 
      new Foo(1, 2)                                                                                                 
      new Foo("S1", "S2")                                                                                           
      new Foo(2, 1)                                                                                                 
    }                                                                                                               
  }