Lazy does not instantiate type parameters

[Katrix]

From my testing, Lazy does not work if more than a single type parameter is involved. I have only tested two myself.

import shapeless._

object LazyTest {

  new FindSimpleFooer[Int].find
  new FindLazySimpleFooer[Int].find
  new FindFooer[Int].find
  new FindLazyFooer[Int].find
}

class FindSimpleFooer[Tpe] {
  def find(implicit fooer: SimpleFooer[Tpe]) = fooer
}

class FindLazySimpleFooer[Tpe] {
  def find(implicit fooer: Lazy[SimpleFooer[Tpe]]) = fooer
}

class FindFooer[Tpe] {
  def find[F <: Foo](implicit fooer: Fooer[Tpe, F]) = fooer
}

class FindLazyFooer[Tpe] {
  def find[F <: Foo](implicit fooer: Lazy[Fooer[Tpe, F]]) = fooer
}

trait Foo
case class BarFoo(i: Int) extends Foo

trait SimpleFooer[Tpe] {
  def makeFoo(obj: Tpe): Foo
}
object SimpleFooer {
  implicit val barFooer: SimpleFooer[Int] = (obj: Int) => BarFoo(obj)
}

trait Fooer[Tpe, FooTpe <: Foo] {
  def makeFoo(obj: Tpe): FooTpe
}
object Fooer {
  implicit val barFooer: Fooer[Int, BarFoo] = (obj: Int) => BarFoo(obj)
}

[joroKr21]

Lazy can't know what is F - it's probably Nothing

[Katrix]

It works fine when Lazy is not present though. Only the last one of the four above fails.

[joroKr21]

I meant that the problem is F <: Foo and not that there are two type parameters.

[Katrix]

That bound is clearly needed as that's the bound of Fooer. Even if you remove that bound though, it still fails.

[joroKr21]

Yeah the reason is that Lazy is using a macro and inside we programatically ask the compiler to infer an implicit with that type, but that doesn't correspond exactly to what the compiler is doing. So we ask to infer Fooer[Tpe, F] where F is the type parameter and instead we should try to substitute it with a wildcard and ask for Fooer[Tpe, ? <: Foo]. I have a WIP for a fix, let's see if we can make it work.

[joroKr21]

We had to revert the fix, because it breaks kittens