export interacting weirdly with scala.Conversion

[erikerlandson]

Compiler version

3.0.0

Minimized code

package repro

export wrap.Wrap as Wrap
export wrap.lift as lift

// separate issue: trying to define this at top-level errors out in other ways.
object wrap:
    opaque type Wrap[V, T] = V

    extension[V, T](w: Wrap[V, T])
        def value: V = w

    extension[V](v: V)
        def lift[T]: Wrap[V, T] = v
end wrap

object conversions:
    given g[T]: scala.Conversion[Wrap[Double, T], Wrap[Double, String]] =
        new scala.Conversion[Wrap[Double, T], Wrap[Double, String]]:
            def apply(w: Wrap[Double, T]): Wrap[Double, String] =
                (w.value * 2).lift[String]

Output

scala> val t: Wrap[Double, String] = 1D.lift[Int]                                                                                        
1 |val t: Wrap[Double, String] = 1D.lift[Int]
  |                              ^^^^^^^^^^^^
  |Found:    repro.wrap.Wrap[Double, Int]
  |Required: repro.Wrap²[Double, String]
  |
  |where:    Wrap  is a type in object wrap with bounds <: [V, T] =>> Any
  |          Wrap² is a type in package object wrap$package which is an alias of [V, T] =>> repro.wrap.Wrap[V, T]

Expectation

I would expect scala to understand that repro.wrap.Wrap and repro.Wrap are the same thing, and not error out.

[erikerlandson]

So far, I have not seen any failures of this kind pertaining to other given types that I have defined. This may be specific to scala.Conversion although I don't understand why it would be special with respect to this

[som-snytt]

In the same compilation unit, the error is

   |                                Found:    repro.wrap.Wrap[Double, Int]
   |                                Required: repro.wrap.Wrap[Double, String]

It works anywhere when importing from conversions. Maybe I don't understand the issue.

Is #12591 a similar question, to reconcile two paths through an export, either for behavior or just for messaging?

[erikerlandson]

I believe #12591 is getting at the same idea: In my repro above, the scala.Conversion should automatically convert a Wrap[Double, Int] into a Wrap[Double, String], but the compiler is erroring out because it believes repro.Wrap is different than repro.wrap.Wrap - in other words, it doesn't understand the paths are equivalent, and so it concludes no Conversion object can be created.

[som-snytt]

@erikerlandson it works if you import repro.conversions.given. Is there a reason that shouldn't be required? This is what I tried:

package repro2

@main def test(): Unit =
  import language.implicitConversions
  import repro.{given, *}
  import repro.conversions.given
  val t: Wrap[Double, String] = 1D.lift[Int]
  println(t)

[erikerlandson]

I also imported that in my testing. However, I will play with it some more and see if I can find something else wrong in my code

[erikerlandson]

Out of curiosity, have you tested in a REPL? generally these things work either way but occasionally a repl causes subtle differences

[som-snytt]

I was going to say maybe REPL is not doing your import. I didn't try in REPL, just run class from CLI.

[som-snytt]

Oh right, scala -classpath /tmp doesn't work because of broken option handling. Bummer. Maybe you tried in sbt console?

[erikerlandson]

yes, I've been running with ./mill -i coulomb.console
I've been doing all my testing that way for a while now, with pretty complicated givens and metaprogramming, and it's been working fine. Either I have an error in this code that I haven't found yet (entirely possible) or there's something different about scala.Conversion

[som-snytt]

Aha. For the record

➜  snips ~/projects/dotty/bin/scala
scala> @main def test(): Unit =
     |   import language.implicitConversions
     |   import repro.{given, *}
     |   import repro.conversions.given
     |   val t: Wrap[Double, String] = 1D.lift[Int]
     |   println(t)
     |
def test(): Unit

scala> test()
2.0

scala> import language.implicitConversions

scala> import repro.{given, *}

scala> import repro.conversions.given

scala> val t: Wrap[Double, String] = 1D.lift[Int]
val t: repro.Wrap[Double, String] = 2.0

[erikerlandson]

weird - well I'll have to double check my local reproducer then

[erikerlandson]

so... my reproducer above also works for me, I might have missed the .given on import

However, I did figure out what was different about scala.Conversion that makes it fail. My "real" definition is:

given g1[U1, U2](using conv: Coefficient[U1, U2]):
        scala.Conversion[Quantity[Double, U1], Quantity[Double, U2]] =
    new scala.Conversion[Quantity[Double, U1], Quantity[Double, U2]]:
        val c = conv.coef.toDouble
        def apply(q: Quantity[Double, U1]): Quantity[Double, U2] =
            (q.value * c).withUnit[U2]

And what's happening is that scala.Conversion's signature is Conversion[-T, +U], and it's those covariance and contravariance modifiers that are causing my chained using conv: Coefficient[U1, U2] to fail down inside the metaprogramming. All my other definitions are invariant - I can reproduce similar failures in other types if I add covariance modifiers like for Conversion

[erikerlandson]

actual error looks like this:

scala> summon[scala.Conversion[Quantity[Double, Yard], Quantity[Double, Meter]]]
1 |summon[scala.Conversion[Quantity[Double, Yard], Quantity[Double, Meter]]]
  |                                                                         ^
  |units are not convertable: (TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class <root>)),object scala),Any)) (TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class <root>)),object scala),Nothing))

almost like scala is forcing the types to Any, Nothing somewhere, which is interesting since Any => Nothing is the subclass of all functions

[som-snytt]

The old joke for Scala 2 was to switch variances until the code compiles.

I think for Scala 3, it's add transparent inline. Not sure if this comment is relevant to your code.

[erikerlandson]

Yes, that other issue looks very similar.

Hilarious, it was the definition for Coefficient that needed to be transparent inline - I had deliberately removed that since the result didn't seem to require any dependent typing "and why make the compiler work harder" 😆

    transparent inline given [U1, U2]: Coefficient[U1, U2] =
        ${ coulomb.infra.meta.coefficient[U1, U2] }

[erikerlandson]

Works now:

scala> val t: Quantity[Double, Meter] = (1D.withUnit[Yard])
val t: coulomb.Quantity[Double, coulomb.si.Meter] = 0.9144