Scala:如何使函数的返回类型具有通用性并依赖于运行时参数

Question

假设我有：

class Animal
class Bird extends Animal
class Dog extends Animal

如何编写一个函数，根据提供的参数返回运行时类型（Bird或Dog）。

我正在尝试类似的东西：

import scala.reflect.ClassTag
def createAnimal[T <: Animal : ClassTag](doesItBark: Boolean): T = {
    if (doesItBark) return new Dog()
    else return new Bird()
}

val azor = createAnimal(doesItBark = true) //azor's type should be Dog

这不起作用。

有可能在Scala中做这样的事情吗？

Answer 1

这是不可能的。方法的返回类型必须在编译时已知，即它返回类型T。但是，必须在调用方法时确定类型参数T，，而不是在之后。调用者必须事先知道类型，所以在这里您能做的最好的事情就是返回Animal。

val newAnimal: ??? = createAnimal(runtimeParam)
           //   ^ What type goes here? 
           //     The compiler needs to infer it, but it can't that way

因此，当调用createAnimal时，您需要期望Dog、Bird或Animal。既然你不知道那可能是什么，你只能说它是Animal。如果必要的话，你可以稍后使用类型测试来检查你得到了什么。

除非您自己填写，否则type参数不会起任何作用。否则，你应该有：

def createAnimal(doesItBark: Boolean): Animal = {
    if (doesItBark) return new Dog()
    else return new Bird()
}

Answer 2

这是否可能在很大程度上取决于如何定义问题。用自定义类型类编写类似的东西并不难：

class Animal
class Bird extends Animal
class Dog extends Animal
sealed trait ChooseAnimal[A <: Animal] { def createAnimal: A }
val isBarker: ChooseAnimal[Dog] = new ChooseAnimal[Dog] {
  def createAnimal: Dog = new Dog
}
val isNotBarker: ChooseAnimal[Bird] = new ChooseAnimal[Bird] {
  def createAnimal: Bird = new Bird
}
def createAnimal[A <: Animal](choose: ChooseAnimal[A]): A =
  choose.createAnimal

然后：

scala> createAnimal(isBarker)
res0: Dog = Dog@25cd1055
scala> createAnimal(isNotBarker)
res1: Bird = Bird@1f4e89bc

注意适当的静态类型。这不是你想要的，但很相似。如果你真的想使用Boolean作为选择器，你需要像Shapeless:这样的东西

import shapeless._
trait ChooseBarker[B <: Boolean, A <: Animal] { def createAnimal: A }
implicit val barker: ChooseBarker[Witness.`true`.T, Dog] =
  new ChooseBarker[Witness.`true`.T, Dog] { def createAnimal: Dog = new Dog }
implicit val nonBarker: ChooseBarker[Witness.`false`.T, Bird] =
  new ChooseBarker[Witness.`false`.T, Bird] { def createAnimal: Bird = new Bird }
def createAnimal[B <: Boolean, A <: Animal](w: Witness.Aux[B])(implicit
  choose: ChooseBarker[B, A]
): A = choose.createAnimal

然后：

scala> createAnimal(true)
res0: Dog = Dog@46c09af6
scala> createAnimal(false)
res1: Bird = Bird@186b9fc2

我们再次得到正确的静态类型。

这种方法仍然有一些局限性——例如，如果论点不是字面意义上的，你必须确保你有一个Witness实例——但它与你的要求非常接近，我认为我们不应该说这种事情是不可能的。

---

值得注意的是，如果你真的想，你甚至可以不使用类型参数：

import shapeless._
sealed trait ChooseBarker[B] extends DepFn0 { type Out <: Animal }
object ChooseBarker {
  type Aux[B, A <: Animal] = ChooseBarker[B] {
    type Out = A
  }
  def mk[B, A <: Animal](a: A): Aux[B, A] = new ChooseBarker[B] {
    type Out = A
    def apply(): A = a
  }
  implicit val barker: Aux[Witness.`true`.T, Dog] = mk(new Dog)
  implicit val nonBarker: Aux[Witness.`false`.T, Bird] = mk(new Bird)
}
def createAnimal(w: Witness)(implicit choose: ChooseBarker[w.T]): choose.Out =
  choose()

然后：

scala> val dog: Dog = createAnimal(true)
dog: Dog = Dog@1681d515
scala> val bird: Bird = createAnimal(false)
bird: Bird = Bird@76634045

这一切都得益于路径相关类型的魔力。