Implicit view not found involving an uninstantiated type variable

[allanrenucci]

This fails to compile with Dotty

class Test {
  implicit def implicitContainer[C[_], T](
    implicit t: C[T] => Traversable[T]): C[T] = ???

  implicitly[List[Char]]
}

-- Error: tests/allan/Test.scala:5:24 ------------------------------------------
5 |  implicitly[List[Char]]
  |                        ^
  |no implicit argument of type scala.collection.immutable.List[Char] found for parameter e of method implicitly in object Predef

Note that this compiles:

class Test {
  implicitly[List[Char] => Traversable[Char]]
}

[smarter]

I think you may have minimized this too much, this only succeeds in scalac because C[_] is instantiated to Nothing which is not something we'd like to have in dotty since C[_] is higher-kinded and Nothing isn't.

[allanrenucci]

class Arbitrary[T]

object Arbitrary {
  def arbitrary[T](implicit a: Arbitrary[T]): T = ???

  implicit def arbContainer[C[_],T](implicit t: C[T] => Traversable[T]): Arbitrary[C[T]] = ???

  val arbString = arbitrary[List[Char]]
}

scalac resolves:

val arbString: List[Char] =
  arbitrary[List[Char]](arbContainer[List, Char](scala.Predef.$conforms[List[Char]]));

[smarter]

Thanks! We can reduce it further, this doesn't compile with dotty:

object Test {
  def foo[C[_],T](implicit t: C[T] => Traversable[T]): C[T] = ???

  val a: List[Char] = foo
}

But this does:

object Test {
  def foo[C[_],T](implicit t: C[T] => Traversable[T]): C[T] = ???

  val a: List[Char] = foo[List, Char]
}

The error we get in the first case is:

4 |  val a: List[Char] = foo
  |                         ^
  |        No implicit view available from scala.collection.immutable.List[T]
  |        
  |        where:    T is a type variable with constraint <: Char
  |         => scala.collection.Traversable[T]
  |        
  |        where:    T is a type variable with constraint <: Char
  |        .

[smarter]

We can minimize even more actually:

object Test {
  def foo[C[_]](implicit t: C[Char] => Traversable[Char]): C[Char] = ???

  val a: List[Char] = foo
}

4 |  val a: List[Char] = foo
  |                         ^
  |No implicit view available from scala.collection.immutable.List[Char] => scala.collection.Traversable[Char].

Here the error message is misleading: there is an implicit view from List[Char] to Traversable[Char], the issue is that at the time we do the search we're looking for a view from C[Char] to Traversable[Char], but C gets instantiated before we print the error.