Enum: incosistence of simple case encoding with case object

[dos65]

3.7.0

I had a code that uses enum and class tags which compiles and looks fine but works incorrect due to specifics of encoding for simple case.

It took me some time to realize that simple enum case isn't equal to sealed trait + case object encoding and it doesn't actually creates a type.

Example that puzzled me:

enum Token:
   case Dot
   case Space
   case Word(v: String)

def read[T <: Token](t: Token)(using ct: ClassTag[T]): T =
   t match
      case t: T =>   t
      case _ => throw new Exception(s"$t is not an instance of $ct")

read[Token.Dot.type](Token.Space) // <- no error - while I was expecting to get it
read[Token.Word](Token.Space)      // <- throws error - ok

The ambiguity in this example:

• ClassTag[Token.Word] - is Token.Word everything is fine
• ClassTag[Token.Dot.type] - is Token, there is not Token.Dot type

Expectation

For each enum case there is a proper type and they are diffrerent from each other.

The questions is if it's possible to switch this encoding now or it's too late?

[som-snytt]

Relatedly #23558

There was a third recent issue on this topic.

The idiom is:

//def read[T <: Token](t: Token)(using ct: ClassTag[T]): T =
def read[T <: Token : Typeable](t: Token): T =

I think "proper type" here means "has a Class representation". ("Types are not classes.")

Note the missing interpolator on the exception, which is why dotty needs -Xlint:missing-interpolator.

[sjrd]

Matching using a ClassTag is deprecated for reasons like this. There should be a warning. Use a Typeable argument instead.

[dos65]

Wow, it works well with Typeable. Thx @som-snytt @sjrd

Matching using a ClassTag is deprecated for reasons like this. There should be a warning.

There is no warning

[dos65]

I think "proper type" here means "has a Class representation". ("Types are not classes.")

Yep - class.

I'm anyway wondering if there is an option to make them more like case objects?

I also spend some time trying to understand why the following doesn't work 🥲

enum A:
  case B

classOf[A.B.type] // <- error: (A.B : A) is not a class type

[som-snytt]

I thought it would be interesting to learn where this happens and add a warning but

➜  snips scala-cli run --server=false -S 3.7.2-RC2 -Vprint:typer -source:future i23583.scala
-- Warning: /home/amarki/snips/i23583.scala:13:12 ------------------------------
13 |    case t: T => t
   |            ^
   |Use of `scala.reflect.ClassTag` for type testing may be unsound. Consider using `scala.reflect.TypeTest` instead.

I think -source:future is where warnings go to never do anyone any good.

Edit: it should be a deprecation.

[bishabosha]

I also spend some time trying to understand why the following doesn't work 🥲

classOf[A.B.type] // <- error: (A.B : A) is not a class type

news to me but classOf[1] also doesn't work I guess i never tried. so .type only works for object because of a funny quirk that for object that does mean the singleton class, but for other values it does not