带泛型的返回类型

Question

I have the following code

import scala.concurrent.Future

class RequestType
class Read extends RequestType
class Write extends RequestType

object Main {
  def main(args: Array[String]): Unit = {
  }

  def dbrequest[T <: RequestType](t: T): Future[T] = {
    val dBRequest = new DBRequest
    t match {
      case r: Read => dBRequest.read(r)
      case w: Write => dBRequest.write(w)
   }
  }
}

class DBRequest {
  def read(r: Read): Future[Read] = {
    Future(r)
  }

  def write(w: Write): Future[Write] = {
   Future(w)
  }
}

read and write method return a Future of type RequestType. If T is bounded and Future is covariant, then why is the compiler failing to conform type of Future[Read] or Future[Write] to Future[T]

Answer 1

Your code will compile with one small change.

def dbrequest[T <: RequestType](t: T): Future[RequestType] = {

So why is it that returning Future[RequestType] works and returning Future[T] doesn't, especially since T is bounded the way it is?

Think of it this way: T is resolved at compile time. With every invocation of dbrequest() the compiler turns T into either Read or Write . The match statement, on the other hand, is resolved at run time. So from the compiler's perspective the match statement returns both Read and Write .

As has been pointed out, you don't really need a type parameter in this code, as presented. The following simplification is equivalent.

def dbrequest(t: RequestType): Future[RequestType] = {

Answer 2

If T is bounded and Future is covariant, then why is the compiler failing to conform type of Future[Read] or Future[Write] to Future[T]

Your code would make sense if T was guaranteed to be Read or Write . But it could Read with SomeTrait . Or a singleton type (so even making RequestType , Read and Write sealed wouldn't help). Etc. See my answer to Returning subclass of parameterized type in Scala for a solution (just replace Output in that question with Future ).