implicit resolution of F[A] for introduced F[_] and A

[fommil]

I expected the following code to compile

trait Bar[F[_]]

trait Foo[A]
object Foo {
  implicit def string: Foo[String] = ???
  implicit def bar: Bar[Foo] = ???
}

case class Problem[A](a: A)
object Problem {
  implicit def deriv[A, F[_]](implicit F: F[A], B: Bar[F]): F[Problem[A]] = ???

  deriv[String, Foo] // works

  implicitly[Foo[Problem[String]]]
}

but I get

could not find implicit value for parameter e: Foo[Problem[String]]
[error]   implicitly[Foo[Problem[String]]]
[error]             ^

This is minimised, if you remove the B: Bar[F] constraint, it compiles (but then I don't have everything I need)

Is there a workaround?

[fommil]

(I closed this because I had a typo, then I fixed it and reopened...)

[soronpo]

FYI, works in dotty
https://scastie.scala-lang.org/znkjYw5gQayTwv6r1r15qQ

[soronpo]

The error I'm getting for scalac

Error:(41, 13) diverging implicit expansion for type Foo[Problem[String]]
starting with method deriv in object Problem
  implicitly[Foo[Problem[String]]]

[fommil]

@soronpo that's interesting about dotty! Where is the diverging implicit error coming from? Is this some additional debugging you've got?

[soronpo]

The full error:

Error:(15, 13) diverging implicit expansion for type Foo[Problem[String]]
starting with method deriv in object Problem
  implicitly[Foo[Problem[String]]]
Error:(15, 13) not enough arguments for method implicitly: (implicit e: Foo[Problem[String]])Foo[Problem[String]].
Unspecified value parameter e.
  implicitly[Foo[Problem[String]]]

I'm using TLS 2.12.4 (literal types) with -Xsource:2.13

[Jasper-M]

If implicitly[Foo[Problem[String]]] is inside object Problem I get diverging implicit expansion. If it's outside I get implicit not found.

[soronpo]

If implicitly[Foo[Problem[String]]] is inside object Problem I get diverging implicit expansion. If it's outside I get implicit not found.

In dotty it compiles in either case

[Jasper-M]

If implicitly[Foo[Problem[String]]] is inside object Problem I get diverging implicit expansion. If it's outside I get implicit not found.

Hmm, looks like that implicit not found error was rather because deriv was not in the implicit scope. (although I think it should be, because Problem is part of the type?)

EDIT: I think this is actually the problem here: implicit scope (or implicit priorities?).

If you import the implicits it starts working:

trait Bar[F[_]]

trait Foo[A]
object Foo {
  implicit def string: Foo[String] = ???
  implicit def bar: Bar[Foo] = ???
}

case class Problem[A](a: A)
object Problem {
  implicit def deriv[A, F[_]](implicit F: F[A], B: Bar[F]): F[Problem[A]] = ???

  import Foo._
  implicitly[Foo[Problem[String]]]
}

Still doesn't definitively explain why adding or removing B: Bar[F] makes a difference.

[fommil]

This hack of importing the Foo._ doesn't work in the real (unminimised) version of the problem fthomas/refined#447 it also wouldn't be a feasible workaround. I'd like to take the complexity hit in the deriv definition to avoid the user having to do anything.

To make the minimisation more realistic, let's rename object Problem to object Main.

[fommil]

changing to

object Deriver {
  implicit def deriv[A, F[_]](implicit F: F[A], B: Bar[F]): F[Problem[A]] = ???
}
object Main {
  import Deriver._
  deriv[String, Foo] // works

  import Foo._
  implicitly[Foo[Problem[String]]]
}

I still get

could not find implicit value for parameter e: Foo[Problem[String]]
[error]   implicitly[Foo[Problem[String]]]

[Jasper-M]

Strange. It works for me.

[fommil]

@Jasper-M I'm on scala 2.12.4, what are you using?

[Jasper-M]

Same. Using REPL :paste however. That might make some difference in bizarre edge cases...