Opaque types and implicit specificity

[vincenzobaz]

Minimized code

trait Magic[F]:
  extension (x: Int) def read: F

object Magic:
  given Magic[String]:
    extension(x: Int) def read: String = 
      println("In string")      
      s"$x"

opaque type Foo = String
object Foo:
  import Magic.{given _}
  def apply(s: String): Foo = s

  given Magic[Foo]:
    extension (x: Int) def read: Foo =
      println("In foo")
      Foo(s"$x")
  
  def test: Unit =
    (3.read: Foo)
  

@main def test = {
  Foo.test
}

Output

In string

Expectation

In foo

Remarks

• If import Magic.{given _} is removed, the output is as expected. The question is: should this import change the behavior? given Magic[Foo] should be more specific and preferred to given Magic[String]

Snippet

https://scastie.scala-lang.org/vincenzobaz/tGQhSpQ8TQyiOeTNAvSGbA/104

[b-studios]

I would not expect Foo to be more specific than String in the context of the companion object, since there the equality Foo = String holds.

However, I understand that it is confusing that the (preceding) import shadows the local definition.

Ergonomically, this is related to #9880.

[som-snytt]

I was also confused #8092

In fact, I'm still confused.

[b-studios]

Thanks for reminding me of that issue @som-snytt. There is indeed three different behaviors that would be justifiable.

1. Local definition shadows (what's described here)
2. Implicits are stacked as currently implemented and described by @odersky in Implicit resolution (incorrectly?) picks import #8092.
3. Implicits are in the same scope and trigger an ambiguity.

[odersky]

6a898ad implements

3. Implicits are in the same scope and trigger an ambiguity.

#8092 is unaffected since there the import is properly nested wrt the definition.