Add Typeable class

It is a generalization of ClassTag with a customizable input type and acting on non erased types.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -671,6 +671,8 @@ class Definitions {
   @tu lazy val QuotedMatchingSymClass: ClassSymbol = ctx.requiredClass("scala.quoted.matching.Sym")
   @tu lazy val TastyReflectionClass: ClassSymbol = ctx.requiredClass("scala.tasty.Reflection")
 
+  @tu lazy val TypeableClass = ctx.requiredClass("scala.Typeable")
+
   @tu lazy val Unpickler_unpickleExpr: Symbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
   @tu lazy val Unpickler_unpickleType: Symbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -215,6 +215,8 @@ object StdNames {
     final val Type : N               = "Type"
     final val TypeTree: N            = "TypeTree"
 
+    final val Typeable: N             = "Typeable"
+
     // Annotation simple names, used in Namer
     final val BeanPropertyAnnot: N = "BeanProperty"
     final val BooleanBeanPropertyAnnot: N = "BooleanBeanProperty"

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -678,17 +678,27 @@ class Typer extends Namer
    *  exists, rewrite to `ctag(e)`.
    *  @pre We are in pattern-matching mode (Mode.Pattern)
    */
-  def tryWithClassTag(tree: Typed, pt: Type)(implicit ctx: Context): Tree = tree.tpt.tpe.dealias match {
-    case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper =>
-      require(ctx.mode.is(Mode.Pattern))
-      inferImplicit(defn.ClassTagClass.typeRef.appliedTo(tref),
-                    EmptyTree, tree.tpt.span)(ctx.retractMode(Mode.Pattern)) match {
-        case SearchSuccess(clsTag, _, _) =>
-          typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt)
-        case _ =>
-          tree
-      }
-    case _ => tree
+  def tryWithClassTag(tree: Typed, pt: Type)(implicit ctx: Context): Tree =  {
+    tree.tpt.tpe.dealias match {
+      case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper =>
+        require(ctx.mode.is(Mode.Pattern))
+        inferImplicit(defn.TypeableClass.typeRef.appliedTo(pt, tref),
+        EmptyTree, tree.tpt.span)(ctx.retractMode(Mode.Pattern)) match {
+          case SearchSuccess(clsTag, _, _) =>
+            typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt)
+          case _ =>
+            inferImplicit(defn.ClassTagClass.typeRef.appliedTo(tref),
+              EmptyTree, tree.tpt.span)(ctx.retractMode(Mode.Pattern)) match {
+                case SearchSuccess(clsTag, _, _) =>
+                  typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt)
+                case _ =>
+
+                  tree
+              }
+        }
+
+      case _ => tree
+    }
   }
 
   def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context): NamedArg = {
@@ -1467,7 +1477,7 @@ class Typer extends Namer
     val body1 = typed(tree.body, pt1)
     body1 match {
       case UnApply(fn, Nil, arg :: Nil)
-      if fn.symbol.exists && fn.symbol.owner == defn.ClassTagClass && !body1.tpe.isError =>
+      if fn.symbol.exists && (fn.symbol.owner == defn.ClassTagClass || fn.symbol.owner.derivesFrom(defn.TypeableClass)) && !body1.tpe.isError =>
         // A typed pattern `x @ (e: T)` with an implicit `ctag: ClassTag[T]`
         // was rewritten to `x @ ctag(e)` by `tryWithClassTag`.
         // Rewrite further to `ctag(x @ e)`

docs/docs/reference/other-new-features/typeable.md

@@ -0,0 +1,85 @@
+---
+layout: doc-page
+title: "Typeable"
+---
+
+Typeable
+--------
+
+`Typeable` provides the a generalization of `ClassTag.unapply` where the type of the argument is generalized.
+`Typeable.unapply` will return `Some(x.asInstanceOf[Y])` if `x` conforms to `Y`, otherwise it returns `None`.
+
+```scala
+trait Typeable[S, T <: S] extends Serializable {
+  def unapply(x: S): Option[T]
+}
+```
+
+Just like `ClassTag` it can be used to perform type checks in patterns.
+
+```scala
+type X
+type Y <: X
+
+given Typeable[X, Y] = ...
+
+(x: X) match {
+  case y: Y => ... // safe checked downcast
+  case _ => ...
+}
+```
+
+
+Examples
+--------
+
+Given the following abstract definition of `Peano` numbers that provides `Typeable[Nat, Zero]` and `Typeable[Nat, Succ]`
+
+```scala
+trait Peano {
+  type Nat
+  type Zero <: Nat
+  type Succ <: Nat
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat)
+
+  val Zero: Zero
+
+  val Succ: SuccExtractor
+  trait SuccExtractor {
+    def apply(nat: Nat): Succ
+    def unapply(nat: Succ): Option[Nat]
+  }
+
+  given Typeable[Nat, Zero] {
+    def unapply(x: Nat): Option[Zero] = matchZero(x)
+  }
+
+  given Typeable[Nat, Succ] {
+    def unapply(x: Nat): Option[Succ] = matchSucc(x)
+  }
+
+  protected def matchZero(x: Nat): Option[Zero]
+  protected def matchSucc(x: Nat): Option[Succ]
+}
+```
+
+it will be possible to write the following program
+
+```scala
+val peano: Peano = ...
+import peano.{_, given}
+
+def divOpt(m: Nat, n: Nat): Option[(Nat, Nat)] = {
+  n match {
+    case Zero => None
+    case s @ Succ(_) => Some(safeDiv(m, s))
+  }
+}
+
+val two = Succ(Succ(Zero))
+val five = Succ(Succ(Succ(two)))
+println(divOpt(five, two))
+```
+
+Note that without the `Typeable[Nat, Succ]` the pattern `Succ.unapply` would be unchecked.

library/src/scala/Typeable.scala

@@ -0,0 +1,10 @@
+package scala
+
+/** A `Typeable[S, T]` (where `T <: S`) contains the logic needed to know at runtime if a value of
+ *  type `S` can be downcased to `T`.
+ *
+ *  Unlike `ClassTag`, a `Typeable` must check the type arguments at runtime.
+ */
+trait Typeable[S, T <: S] extends Serializable {
+  def unapply(x: S): Option[T]
+}

tests/run/refined-binding-nat.check

@@ -0,0 +1,6 @@
+Some((SuccClass(SuccClass(ZeroObject)),SuccClass(ZeroObject)))
+Some((ZeroObject,SuccClass(SuccClass(ZeroObject))))
+None
+Some((2,1))
+Some((0,2))
+None

tests/run/refined-binding-nat.scala

@@ -0,0 +1,123 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    app(ClassNums)
+    app(IntNums)
+  }
+
+  def app(peano: Peano): Unit = {
+    import peano.{_, given}
+    def divOpt(m: Nat, n: Nat): Option[(Nat, Nat)] = {
+      n match {
+        case Zero => None
+        case s @ Succ(_) => Some(safeDiv(m, s))
+      }
+    }
+    val two = Succ(Succ(Zero))
+    val five = Succ(Succ(Succ(two)))
+    println(divOpt(five, two))
+    println(divOpt(two, five))
+    println(divOpt(two, Zero))
+  }
+}
+
+trait Peano {
+  type Nat
+  type Zero <: Nat
+  type Succ <: Nat
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat)
+
+  given Typeable[Nat, Zero] {
+    def unapply(x: Nat): Option[Zero] = matchZero(x)
+  }
+
+  given Typeable[Nat, Succ] {
+    def unapply(x: Nat): Option[Succ] = matchSucc(x)
+  }
+
+  // given reflect.ClassTag[Succ] = ???
+
+  protected def matchZero(x: Nat): Option[Zero]
+  protected def matchSucc(x: Nat): Option[Succ]
+
+  implicit def succDeco(succ: Succ): SuccAPI
+  trait SuccAPI {
+    def pred: Nat
+  }
+
+  val Zero: Zero
+
+  val Succ: SuccExtractor
+  trait SuccExtractor {
+    def apply(nat: Nat): Succ
+    def unapply(nat: Succ): Option[Nat]
+  }
+}
+
+object IntNums extends Peano {
+  type Nat  = Int
+  type Zero = Int
+  type Succ = Int
+
+  protected def matchZero(x: Nat): Option[Zero] = if (x == 0) Some(0) else None
+  protected def matchSucc(x: Nat): Option[Succ] = if (x != 0) Some(x) else None
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat) = (m / n, m % n)
+
+  val Zero: Zero = 0
+
+  object Succ extends SuccExtractor {
+    def apply(nat: Nat): Succ = nat + 1
+    def unapply(nat: Succ) = Some(nat - 1)
+  }
+  def succDeco(succ: Succ): SuccAPI = new SuccAPI {
+    def pred: Nat = succ - 1
+  }
+}
+
+object ClassNums extends Peano {
+  trait NatTrait
+  object ZeroObject extends NatTrait {
+    override def toString: String = "ZeroObject"
+  }
+  case class SuccClass(predecessor: NatTrait) extends NatTrait
+
+  type Nat  = NatTrait
+  type Zero = ZeroObject.type
+  type Succ = SuccClass
+
+  protected def matchZero(x: Nat): Option[Zero] = x match {
+    case Zero => Some(Zero)
+    case _ => None
+  }
+  protected def matchSucc(x: Nat): Option[Succ] = x match {
+    case nat: SuccClass => Some(nat)
+    case _ => None
+  }
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat) = {
+    def intValue(x: Nat, acc: Int): Int = x match {
+      case nat: SuccClass => intValue(nat.predecessor, acc + 1)
+      case _ => acc
+    }
+    def natValue(x: Int): Nat =
+      if (x == 0) ZeroObject
+      else new SuccClass(natValue(x - 1))
+    val i = intValue(m, 0)
+    val j = intValue(n, 0)
+    (natValue(i / j), natValue(i % j))
+  }
+
+  val Zero: Zero = ZeroObject
+
+  object Succ extends SuccExtractor {
+    def apply(nat: Nat): Succ = new SuccClass(nat)
+    def unapply(nat: Succ) = Some(nat.predecessor)
+  }
+
+  def succDeco(succ: Succ): SuccAPI = new SuccAPI {
+    def pred: Nat = succ.predecessor
+  }
+
+}

tests/run/refined-binding.check

@@ -0,0 +1,2 @@
+ok
+9

tests/run/refined-binding.scala

@@ -0,0 +1,33 @@
+
+sealed trait Foo {
+
+  type X
+  type Y <: X
+
+  def x: X
+
+  def f(y: Y) = println("ok")
+
+  given Typeable[X, Y] = new Typeable {
+    def unapply(x: X): Option[Y] = Some(x.asInstanceOf[Y])
+  }
+
+  object Z {
+    def unapply(arg: Y): Option[Int] = Some(9)
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    test(new Foo { type X = Int; type Y = Int; def x: X = 1 })
+  }
+
+  def test(foo: Foo): Unit = {
+    import foo.given
+    foo.x match {
+      case x @ foo.Z(i) => // `x` is refined to type `foo.Y`
+        foo.f(x)
+        println(i)
+    }
+  }
+}