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

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 或 @ 987654325@)。

然后，按照隐式解析的规则，我会将更具体的放在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)                                                                                                 
    }                                                                                                               
  }