Scala 中的泛型类型

Question

我想用特定类型重载抽象 class 的构造函数。 例如，我有：

abstract class Polinom(v: T)

所以，当我创建Polinom[String]时，我想调用constructor(String) ，对于 Int 我想调用constructor(Int) 。 如果T != String and T != Int那么我调用constructor(T) 。 另外，对于T == Int我的 object 必须有方法add ，对于T == String - reverse ，对于T != String and T != Int object 没有这个方法。 我怎样才能做到这一点？

Answer 1

将 model 作为ADT会更好，例如：

sealed trait Polinom[T] {
  def v: T
}

object Polinom {
  final case class IntPolinom private[Polinom] (v: Int) extends Polinom[Int] {
    def add(x: Int): IntPolinom =
      this.copy(v = this.v + x)
  }

  final case class StrPolinom private[Polinom] (v: String) extends Polinom[String] {
    def reverse: StrPolinom =
      this.copy(v = this.v.reverse)
  }

  final case class GenericPolinom[T] private[Polinom] (v: T) extends Polinom[T]

  def apply[T](v: Int): IntPolinom =
    IntPolinom(v)

  def apply[T](v: String): StrPolinom =
    StrPolinom(v)

  def apply[T](v: T): GenericPolinom[T] =
    GenericPolinom(v)
}

Answer 2

您可以为此使用证据参数：

class Polinom[T](v: T) {

  def add(i: Int)(implicit ev: T <:< Int) = v + i
  def reverse(implicit ev: T <:< String): String = ev(v).reverse

}

val x = new Polinom(50)
val y = new Polinom("hello")
val z = new Polinom(None)

println(x.add(3))
println(y.reverse)
//println(z.add(3)) <- Isn't allowed. Error: Cannot prove that None.type <:< Int

如果您想要Int和String的特定构造函数并且无法获得足够的隐式证据，您可以这样做：

def this(i: Int)(implicit ev: Int =:= T) = this({
    //do special int stuff here
    println("I am in the special int constructor")
    ev(i)
  })

  def this(s: String)(implicit ev: String =:= T) = this({
    //do special string stuff here
    println("I am in the special string constructor")
    ev(s)
  })

编辑：显然，上述内容不适用于 OP，尽管它似乎对我有用，但您始终可以制作一个伴侣 object 并重载应用方法，正如其他答案所建议的那样。

class Polinom[T] private(v: T)
object Polinom {
  def apply(i: Int): Polinom[Int] = new Polinom(i)
  def apply(s: String): Polinom[String] = new Polinom(s)
  def apply[T](x: T): Polinom[T] = new Polinom(x)
}

val x = Polinom(50)
val y = Polinom("hello")
val z = Polinom(None)

println(x.add(3))
println(y.reverse)
//println(z.add(3)) <- Isn't allowed. Error: Cannot prove that None.type <:< Int

链接到 Scastie （演示如下）

 <script src="https://scastie.scala-lang.org/j8fWjvVFS3CumCo3WbUgqQ.js"></script>

Answer 3

abstract class Polinom[T](v: T)

object Polinom {
  def apply(i: Int): Polinom[Int] = constructor(i)
  def apply(s: String): Polinom[String] = constructor(s)
  def apply[T](v: T): Polinom[T] = constructor(v)
}

Polinom(0)
Polinom("hello")
Polinom(None)

有关add和reverse方法的示例，请参阅此问题的其他答案。