Welcome to Scala 3 Migration Discussions!

[adpi2]

👋 Welcome!

We’re using Discussions as a place to connect with the members of our community. We hope that you:

• Ask questions about the migration to Scala 3.
• Share feedback and ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

[plokhotnyuk]

Currently I cannot migrate the dijon project to Scala 3.

Here is my 1st attempt to use union types but it failed because implicit class that extends scala.Dynamic doesn't work properly with Scala 3 comparing to Scala 2 version that uses emulation of union types.

[adpi2]

Thanks for sharing this! Do you think this incompatibility pattern could be minimized?

It would be great to add it to the incompatibility table.

[plokhotnyuk]

Here are simplified Scastie snippets that reproduce the problem using the same implementation of the implicit class and the same way to call it:

• Scala 2
• Scala 3

[adpi2]

Awesome!

[adpi2]

In the Scala 3 snippet, if arr and obj returns Json then it seems we can make it work:
https://scastie.scala-lang.org/adpi2/RF2YHYpoQ2aYHO6a3UhPiA/4

(note that I also adapted the Json#toString implementation)

[AlterEgo7]

Hello, and thanks for helping out answer questions around migrations. I have been trying out opaque types lately, but can't seem to find a way to have them derive typeclasses automatically based on the original type.

The specific example I'm trying to work with is to create a circe Encoder from an opaque type that is a String. The only solution so far is to create a given using a String encoder.

Is there a solution at this point where the derivation is automatic, or semi-automatic?

Edit: I have found no reference to opaque types in the page about the new typeclass derivation system in Scala 3.

[adpi2]

Whether it is derived or given implicitly does not change anything.

import scala.reflect.ClassTag

trait Show[T]:
  def show: Unit

object Show:  
  inline def derived[T](using tag: ClassTag[T]): Show[T] =
    new Show[T]:
      def show: Unit = println(tag.runtimeClass.getName)

case class Foo(a: Int) derives Show
opaque type Bar = Foo

@main def test =
  summon[Show[Bar]].show

Here Show[Foo] is derived but I can summon it for the opaque type Bar.

[adpi2]

We don't need any specific import.

import example.{Show, Foo}

opaque type Bar = Foo

@main def test =
  summon[Show[Bar]].show

[AlterEgo7]

Ah I see, my issue seems to be with scoping. The derived instance exists where the opaque type definition is in scope, but not outside of it unless I expose it with a given in the companion object. Because my case looks more like the following:

trait Show[T] {
  def show: Unit
}

given Show[String] with
  def show: Unit = println("foo")

object A {
  opaque type Foo = String
}

@main def test =
  import A.Foo
  summon[Show[String]]
  summon[Show[Foo]]

just the opaque type is defined in a different file.

[adpi2]

If you move the given Show[String] to the object Show companion it should work with no import.

Or you have to import it explicitly with import example.given where example is the name of the package containing the given Show[String]

[AlterEgo7]

Got it, thank you for your time.