Distinguish Scala-3 Enum and Sealed Traits - scala

Question

Is it possible to distinguish Scala-3 enums and sealed traits using Mirrors or even Macros?
transparent inline def isScalaEnum[A]: Boolean = ${ isScalaEnumImpl[A] }
private def isScalaEnumImpl[A: Type](using q: Quotes): Expr[Boolean] = ???
For example, how do you implement the above macro?
sealed trait T
case class A(x: Int) extends T
case class B(x: String) extends T
enum Color(val rgb: Int):
case Red extends Color(1)
case Green extends Color(2)
isScalaEnum[T] should be false
isScalaEnum[Color] should be true

Answer 1

You could do it with <:< and NotGiven:
<:< reflect.Enum for checking whether your type is subclass of scala.reflect.Enum (which is true only for Scala 3 enums)
NotGiven for translating the absence of <:<-evidence into a false
Here is how it can be implemented:
import scala.util.NotGiven
case class IsEnum[X](value: Boolean)
given isEnum[X](using X <:< reflect.Enum): IsEnum[X] = IsEnum(true)
given isNotEnum[X](using NotGiven[X <:< reflect.Enum]): IsEnum[X] = IsEnum(false)
inline def isScalaEnum[X](using inline ev: IsEnum[X]): Boolean = ev.value
Here is how it can be used:
enum Foo:
case Bar
sealed trait NotFoo
#main def demo(): Unit =
println(isScalaEnum[Foo]) // true
println(isScalaEnum[NotFoo]) // false
Update
If you want to have more precise type information at compile time, just transparently inline all the things:
import scala.util.NotGiven
case class IsEnum[X](value: Boolean)
transparent inline given isEnum[X](using X <:< reflect.Enum): IsEnum[X] =
IsEnum(true)
transparent inline given isNotEnum[X](using NotGiven[X <:< reflect.Enum]): IsEnum[X] =
IsEnum(false)
transparent inline def isScalaEnum[X](using inline ev: IsEnum[X]): ev.value.type =
ev.value
It then behaves similarly to the test cases that you've mentioned in your own answer, with Null and Nothing being notable exceptions:
enum Foo:
case Bar
enum FooS(x:String):
case Bar extends FooS("str")
sealed trait NotFoo
inline val a: true = isScalaEnum[Foo]
inline val b: true = isScalaEnum[Foo.Bar.type]
inline val c: true = isScalaEnum[FooS]
inline val d: true = isScalaEnum[FooS.Bar.type]
inline val e: false = isScalaEnum[NotFoo]
inline val f: false = isScalaEnum[Int]
inline val g: false = isScalaEnum[String]
inline val x: true = isScalaEnum[Null]
inline val y: true = isScalaEnum[Nothing]

Answer 2

Thanks to #Gaël J's comment, here is what I came up with. Unfortunately, it uses Macro, but a simple one.
In one file:
import scala.quoted.*
transparent inline def isScalaEnum[A]: Boolean =
${ isScalaEnumImpl[A] }
private def isScalaEnumImpl[A: Type](using q: Quotes): Expr[Boolean] =
import q.reflect.*
TypeRepr.of[A].asType match
case '[Null] => Expr(false) // Return false for Null, regardless of whether explicit-nulls are enabled.
case '[Nothing] => Expr(false) // I prefer false for Nothing
case '[reflect.Enum] => Expr(true)
case _ => Expr(false)
Here are my test:
enum Foo:
case Bar
enum FooS(x:String):
case Bar extends FooS("str")
sealed trait NotFoo
#main
def demo(): Unit =
inline val a: true = isScalaEnum[Foo]
inline val b: true = isScalaEnum[Foo.Bar.type]
inline val c: true = isScalaEnum[FooS]
inline val d: true = isScalaEnum[FooS.Bar.type]
inline val e: false = isScalaEnum[NotFoo]
inline val f: false = isScalaEnum[Int]
inline val g: false = isScalaEnum[Null]
inline val h: false = isScalaEnum[Nothing]
Please let me know if you think there is an easier/better solution, or there is something wrong with what I provided here.
EDIT:
Thanks to #Andrey Tyukin comments/answers, I changed the macro to treat Null and Nothing explicitly.

Answer 3

Thanks to #Andrey Tyukin and #Gaël J, here is a simpler version.
transparent inline def isScalaEnum[X]: Boolean = inline compiletime.erasedValue[X] match
case _: Null => false // Return false for Null, regardless of whether explicit-nulls are enabled.
case _: Nothing => false // I prefer false for Nothing
case _: reflect.Enum => true
case _ => false
Here are some tests:
enum Foo:
case Bar
enum FooS(x:String):
case Bar extends FooS("str")
sealed trait NotFoo
inline val a: true = isScalaEnum[Foo]
inline val b: true = isScalaEnum[Foo.Bar.type]
inline val c: true = isScalaEnum[FooS]
inline val d: true = isScalaEnum[FooS.Bar.type]
inline val e: false = isScalaEnum[NotFoo]
inline val f: false = isScalaEnum[Int]
inline val g: false = isScalaEnum[String]
inline val x: false = isScalaEnum[Null]
inline val y: false = isScalaEnum[Nothing]