Type computed to `Any`, expect `T`

[He-Pin]

Compiler version

If you're not sure what version you're using, run print scalaVersion from sbt
(if you're running scalac manually, use scalac -version instead).

3.3.4 & 3.6.2

Minimized code

Works code 1:

import scala.util.Try
import scala.concurrent.Future
import scala.concurrent.Awaitable

object CompletedFuture {
  def unapply[T](f: Future[T]): Option[Try[T]] = f.value
}

def result[T](future: Awaitable[T]): T = future match {
  case CompletedFuture(result:Try[T] @unchecked) => result.get
  case _                       => ???
}

println(result(Future.successful(1)))

Works code 2:

import scala.util.Try
import scala.concurrent.Future
import scala.concurrent.Awaitable

object CompletedFuture {
  def unapply[T](f: Future[T]): Option[Try[T]] = f.value
}

def result[T](future: Awaitable[T]): T = future match {
  case CompletedFuture(result:Try[T] ) => result.get
  case _                       => ???
}

println(result(Future.successful(1)))

Works code 3:

import scala.util.Try
import scala.concurrent.Future
import scala.concurrent.Awaitable

object CompletedFuture {
  def unapply[T](f: Future[T]): Option[Try[T]] = f.value
}

def result[T](future: Future[T]): T = future match {
  case CompletedFuture(result) => result.get
  case _                       => ???
}

println(result(Future.successful(1)))

Bad code :

import scala.util.Try
import scala.concurrent.Future
import scala.concurrent.Awaitable

object CompletedFuture {
  def unapply[T](f: Future[T]): Option[Try[T]] = f.value
}

def result[T](future: Awaitable[T]): T = future match {
  case CompletedFuture(result) => result.get
  case _                       => ???
}

println(result(Future.successful(1)))

https://scastie.scala-lang.org/He-Pin/2UboOKGuRp2CXe5XS3ZCXQ/1

Output

Found:    Any
Required: T

Expectation

Works as 2.13.x

[Linyxus]

A minimisation:

trait Awaitable[+T]
trait Future[+T] extends Awaitable[T]

object CompletedFuture:
  def unapply[T](f: Future[T]): Option[T] = ???

def result1[T](future: Awaitable[T]): T = future match
  case CompletedFuture(result) => result  // error
  case _ => ???

[Linyxus]

This is actually the intended behavior. This is due to the "old paradox" of GADT in Scala. The question is: given a value future: Awaitable[T], if, via pattern-matching, we come to know that this value is also of type Future, then can we be sure that it is of type Future[T]?

Actually no. The crux of the problem is that both Future and Awaitable can be further extended. For instance:

object Unsound extends Future[Any] with Awaitable[Int]

It will be an Awaitable[Int], but it is unsound to assume that it is also of Future[Int]. In the previous example, it is sound to say what we get is a Future[Any].

If we made Future a final class, the code will compile:

trait Awaitable[+T]
final class Future[+T] extends Awaitable[T]

//object Unsound extends Future[Any] with Awaitable[Int]

object CompletedFuture:
  def unapply[T](f: Future[T]): Option[T] = ???

def result1[T](future: Awaitable[T]): T = future match
  case CompletedFuture(result) => result  // no error any more!
  case _ => ???

[lrytz]

When not using an extractor, there's a missing "unchecked" warning: #24322