Class Scala：比较泛型类的类型

在这个问题上有很多问题，但遗憾的是，似乎没有一个能解决我的问题

我已经编写了一个通用的scala类，我们称之为

class MyClass[A]() { ... }

以及相应的对象：

object MyClass() { ... }

在MyClass中，我想定义一个函数，该函数的行为取决于给定的类型a。例如，让我们假设我想定义一个类型（a，a）=>Boolean的“较小”函数，默认情况下，无论元素是什么，都返回“true”，但对于某些类型（如Int、Float等），它将返回正确的结果

我的想法是用以下方式将“小”定义为班级成员：

class MyClass[A]() {

    val someArray = new Array[A](1) // will be referred to later on

    var smaller:(A,A) => Boolean = MyClass.getSmallerFunction(this)

    ...some Stuff...

}

object MyClass {

    def getSmallerFunction[A](m:MyClass[A]):(A,A) => Boolean = { 

        var func = (a:Boolean, b:Boolean) => true

        // This doesn't compile, since the compiler doesn't know what 'A' is
        if(A == Int) func = ((a:Int, b:Int) => (a<b)).asInstanceOf[(A,A) => Boolean)]

        // This compiles, but always returns true (due to type erasure I guess?)
        if(m.isInstanceOf[MyClass[Float]]) func = ((a:Float, b:Float) => (a<b)).asInstanceOf[(A,A) => Boolean)]

        // This compiles but always returns true as well due to the newly created array only containing null-elements
        if(m.someArray(0).isInstanceOf[Long]) func = ((a:Long, b:Long) => (a<b)).asInstanceOf[(A,A) => Boolean)]

    }

    ...some more stuff...

}

例如，当我想知道实例m:MyClass的类型A是否为“Float”时，我可以使用“m.dummy.isInstanceOf[Float]”。 为了实现这一点，我在MyClass对象中添加了一组我需要的所有数据类型的预定义隐式值：

object MyClass {

    implicit val floatDummy:Float = 0.0f
    implicit val intDummy:Int = 0
    ...

}

---

虽然这确实不是一个合适的解决方案，但它似乎让我很好地解决了这个问题。

我省略了一大堆东西，因为如果我诚实的话，我仍然不完全确定你想做什么。但这里有一个解决方案可以帮助你

trait MyClass[A] {
  def smaller: (A,A) => Boolean
}

object MyClass {
  implicit object intMyClass extends MyClass[Int] {
    def smaller = (a:Int, b:Int) => (a < b)
  }
  implicit object floatMyClass extends MyClass[Float] {
    def smaller = (a:Float, b:Float) => (a < b)
  }
  implicit object longMyClass extends MyClass[Long] {
    def smaller = (a:Long, b:Long) => (a < b)
  }

  def getSmallerFunction[T : MyClass](a: T, b: T) = implicitly[MyClass[T]].smaller(a, b)
}

它自动知道正确的使用方法。您可以扩展此技术来处理数组示例

---

编辑：我刚刚意识到您需要返回实际函数。在我的示例中，与您的示例一样，类型参数丢失。但是，如果在一天结束时，您只是希望能够根据方法的类型有选择地调用它们，那么我详细介绍的方法应该会对您有所帮助。

如果（m.isInstanceOf…），这不是

吗？哦，是的，谢谢。我的错误修复了它。现在看起来很有趣。
trait MyClass[A] {
  def smaller: (A,A) => Boolean
}

object MyClass {
  implicit object intMyClass extends MyClass[Int] {
    def smaller = (a:Int, b:Int) => (a < b)
  }
  implicit object floatMyClass extends MyClass[Float] {
    def smaller = (a:Float, b:Float) => (a < b)
  }
  implicit object longMyClass extends MyClass[Long] {
    def smaller = (a:Long, b:Long) => (a < b)
  }

  def getSmallerFunction[T : MyClass](a: T, b: T) = implicitly[MyClass[T]].smaller(a, b)
}

println(MyClass.getSmallerFunction(1, 2))