Language: Scala · Versions: Scala 3.6.2
The problem
I defined two distinct opaque type aliases over String (opaque type UserId = String and opaque type OrderId = String) in separate companion scopes to guarantee zero-overhead type safety. At compile time, userId == orderId is rightly rejected under language.strictEquality. However, when values of UserId and OrderId are stored in a heterogeneous collection (List[Any]) or matched in a match expression, runtime pattern matching (case u: UserId =>) silently succeeds on an OrderId because both erase to java.lang.String!
Minimal example
object Ids:
opaque type UserId = String
object UserId:
def apply(s: String): UserId = s
opaque type OrderId = String
object OrderId:
def apply(s: String): OrderId = s
import Ids.*
@main def testOpaqueMatch(): Unit =
val order: Any = OrderId("ord-999")
order match
case u: UserId => println(s"Matched as UserId: $u") // Matches OrderId at runtime!
case _ => println("Not a UserId")
Expected
Understand how to prevent unchecked runtime pattern matching on Scala 3 opaque types (or pair an opaque type with scala.reflect.TypeTest) without paying heap wrapper overhead on the fast path.
What happens instead
Because UserId and OrderId both erase to String outside Ids (as subtype bounds of Any), case u: UserId => emits an unchecked warning (the type test for Ids.UserId cannot be checked at runtime because it refers to an abstract type member or type parameter) and compiles to instanceof Object (or instanceof String if upper-bounded by : String), matching any OrderId!
Is there a way in Scala 3.6 to forbid runtime type tests on an opaque type with a hard compile error (beyond -Werror), or provide a custom TypeTest[Any, UserId] that validates a prefix/format at runtime?
Short version: a TypeTest fixes the compile-time story, but it can't make two plain Strings distinguishable. I haven't compiled any of this, so treat it as reasoning from the Scala 3 reference, not a verified run.
Option 1: a TypeTest that validates a format
If a given TypeTest[Any, UserId] is in scope, Scala 3 uses it for case u: UserId => instead of emitting an unchecked test. See the "TypeTest" section of the Scala 3 reference.
import scala.reflect.TypeTest
object Ids:
opaque type UserId = String
object UserId:
def apply(s: String): UserId = s
given TypeTest[Any, UserId] with
def unapply(x: Any): Option[x.type & UserId] = x match
case s: String if s.startsWith("usr-") => Some(s.asInstanceOf[x.type & UserId])
case _ => None
opaque type OrderId = String
object OrderId:
def apply(s: String): OrderId = s
given TypeTest[Any, OrderId] with
def unapply(x: Any): Option[x.type & OrderId] = x match
case s: String if s.startsWith("ord-") => Some(s.asInstanceOf[x.type & OrderId])
case _ => None
The given sits in the companion, so it is found through implicit scope. This only works because usr- and ord- are different formats. If the two IDs can have the same shape (say, bare UUIDs), no runtime predicate can tell them apart. The type information is gone after erasure, and TypeTest can't bring it back.
Option 2: if you need real runtime identity, box
case class UserId(value: String) extends AnyVal
case class OrderId(value: String) extends AnyVal
While they are statically typed there is no wrapper allocation. Once they are widened to Any or put in a List[Any], they box. Then case u: UserId is a real class test and can't match an OrderId. You pay the allocation only on the heterogeneous path, which is roughly the trade-off you asked about. Opaque types can't offer this, because there is nothing to tag the value with.
Making the unchecked test a hard error
I don't know of a dedicated flag. The closest I know is to promote that one warning to an error with -Wconf, matching on the message text:
-Wconf:msg=the type test for:e
I believe -Wconf with msg= filters exists in Scala 3 since 3.3, but I haven't checked that it matches this exact warning. Compile once, copy the real message text from the output, and tune the regex to it.
One claim to check
You say the test compiles to instanceof Object or instanceof String. Run javap -c on the compiled class to see which. Either way the conclusion holds: at runtime nothing separates the two IDs.