从子类型到零类型的默认类型转换，零参数函数

Question

I am trying to understand the mechanism with which scala implements default type converions from sub to super type in scala.Predef. From the literature I gathered that this is done with the function

implicit def conforms[A] = new A<:<A { def apply(a:A)=a }

The parameterless function conforms[A] returns the implicit conversion A=>B as its only function value (as a callable of type A=>A and thus of type A=>B, whenver A<:B).

However when the compiler looks for an implicit type conversion it needs an implicit value of type A=>B not a function returning such a value. Thus my question:

When looking for a default type conversion from A=>B, where A<:B, how does the compiler get from the function conforms[A] to its unique value.

Answer 1

The implicit resolution seeks for subtypes too, A <: B => A => A <: A => B , as in List[Int] <: Seq[Int] .

scala> :paste
// Entering paste mode (ctrl-D to finish)

implicit val x: List[Int] = List(1, 2, 3)
def f(implicit x: Seq[Int]): Int = x.head
f

// Exiting paste mode, now interpreting.

x: Seq[Int] = List(1, 2, 3)
f: (implicit x: Seq[Int])Int
res1: Int = 1

So when making type conversion we look for A => B with A <: B , and A => A fits.

---

I'm not sure if I understood you right, but the defs are followed while searching for value of the needed type. It doesn't matter whether function takes zero, one, or more parameters. For example with zero:

implicit def implicitList[A]: List[A] = List() //the only obvious case
scala> implicitly[Seq[Int]]
// res0: Seq[Int] = List()

Or two:

case class Foo(str: String)
case class Bar(str: String)
case class Quux(str: String)

implicit val foo = Foo("foo")
implicit val bar = Bar("bar")

// how to build quux:
implicit def quux(implicit foo: Foo, bar: Bar): Quux = Quux(foo.str + bar.str)

implicitly[Quux]
// res2: Quux = Quux(foobar)

If we add any of:

implicit def quux2(implicit quux: Quux): Quux = quux
implicit def quux3(implicit foo: Foo): Quux = Quux(foo.str)
implicit val quux4: Quux = Quux("quux")
implicit def quux5[A]: Quux = Quux("poly")

We make implicit resolution undecidable for Quux :

scala> implicitly[Quux]
<console>:29: error: ambiguous implicit values:
 both method quux of type (implicit foo: Foo, implicit bar: Bar)Quux
 and method quux2 of type (implicit quux: Quux)Quux
 match expected type Quux
              implicitly[Quux]
                    ^

Ie there could be only one def or val in scope returning the type we are interested. And that is easy to verify statically.

But they will work if any of those is the only one in scope.