Scala 指定要调用未知泛型类型的方法

假设我有如下代码：

abstract class GenericType[T]{
    val someSeq: Seq[T]

    def list() = for(item <- someSeq) println(item)
}

class ConcreteType extends GenericType[Int] {
    val someSeq = Seq(1, 2, 3)
}

object MyApp {
    def main(args: Array[String]) {
        val ct = new ConcreteType
        ct.list()
    }
}

---

然后将

main

打印出2 3（即，

for（item的结果）您需要指定返回类型“mtehodToCall”，例如，我使用T

  abstract class GenericType[T]{
    def someSeq: Seq[T]
    def methodToCall: T => T

    def list() = for(item <- someSeq) println(methodToCall(item))
  }

  class ConcreteType extends GenericType[Int] {
    val someSeq = Seq(1, 2, 3)
    val methodToCall: Int => Int = math.max(_, 2)
  }

  new ConcreteType().list()

抽象类GenericType[T]{
def someSeq:Seq[T]
def methodToCall:T=>T
def list（）=for（item Int=math.max（512;，2）
}
新建ConcreteType（）.list（）
您需要指定“mtehodToCall”的返回类型，例如，我使用T

  abstract class GenericType[T]{
    def someSeq: Seq[T]
    def methodToCall: T => T

    def list() = for(item <- someSeq) println(methodToCall(item))
  }

  class ConcreteType extends GenericType[Int] {
    val someSeq = Seq(1, 2, 3)
    val methodToCall: Int => Int = math.max(_, 2)
  }

  new ConcreteType().list()

抽象类GenericType[T]{
def someSeq:Seq[T]
def methodToCall:T=>T
def list（）=for（item Int=math.max（512;，2）
}
新建ConcreteType（）.list（）
您不能这样做。您只能返回值，而方法不是值。但是，您可以获取函数并传递lambda，或者通过η-展开将方法转换为函数

abstract class GenericType[T] {
  def someSeq: Seq[T]

  type MapResult
  def map: T => MapResult

  def list() = someSeq.foreach(map andThen println)
}

class ConcreteType extends GenericType[Int] {
  override val someSeq = Seq(1, 2, 3)

  override type MapResult = Int
  override val map = 2.max(_)
}

您不能这样做。您只能返回值，而方法不是值。但是，您可以获取函数并传递lambda，或者通过η-展开将方法转换为函数

abstract class GenericType[T] {
  def someSeq: Seq[T]

  type MapResult
  def map: T => MapResult

  def list() = someSeq.foreach(map andThen println)
}

class ConcreteType extends GenericType[Int] {
  override val someSeq = Seq(1, 2, 3)

  override type MapResult = Int
  override val map = 2.max(_)
}

我个人会尝试使用类型类。以下是示例：

  trait MethodToCall[T, R] {
    def invoke(obj: T): R
  }

  implicit object IntToCall extends MethodToCall[Int, Int] {
    override def invoke(obj: Int): Int = obj.max(2)
  }

  abstract class GenericType[T]{
    def someSeq: Seq[T]

    def list[R](implicit mtc: MethodToCall[T, R]) =
      for(item <- someSeq) println(mtc.invoke(item))
  }

  class ConcreteType extends GenericType[Int] {
    val someSeq = Seq(1, 2, 3)
  }

  new ConcreteType().list[Int]

trait方法调用[T，R]{
def调用（对象：T）：R
}
隐式对象IntToCall扩展了MethodToCall[Int，Int]{
覆盖def调用（obj:Int）：Int=obj.max（2）
}
抽象类泛型[T]{
def someSeq:Seq[T]
定义列表[R]（隐式mtc:MethodToCall[T，R]）=
对于（item，我个人会尝试使用类型类。以下是示例：

  trait MethodToCall[T, R] {
    def invoke(obj: T): R
  }

  implicit object IntToCall extends MethodToCall[Int, Int] {
    override def invoke(obj: Int): Int = obj.max(2)
  }

  abstract class GenericType[T]{
    def someSeq: Seq[T]

    def list[R](implicit mtc: MethodToCall[T, R]) =
      for(item <- someSeq) println(mtc.invoke(item))
  }

  class ConcreteType extends GenericType[Int] {
    val someSeq = Seq(1, 2, 3)
  }

  new ConcreteType().list[Int]

trait方法调用[T，R]{
def调用（对象：T）：R
}
隐式对象IntToCall扩展了MethodToCall[Int，Int]{
覆盖def调用（obj:Int）：Int=obj.max（2）
}
抽象类泛型[T]{
def someSeq:Seq[T]
定义列表[R]（隐式mtc:MethodToCall[T，R]）=
例如（上面的item
max
只是一个例子。我实际上试图调用
T
的一些方法（我已经知道它的类型签名）。
max
上面只是一个例子。我实际上试图调用
T
的一些方法（我已经知道它的类型签名）。当然，一种解决方案是使用反射并指定要调用的方法的字符串名称，但这会产生我希望避免的性能问题。当然，一种解决方案是使用反射并指定要调用的方法的字符串名称，但这会产生我希望避免的性能问题。