Add Quotable type class

Quotable is a way to lift expressions from T to Expr[T] without
having to go through quotes.

This makes writing staged interpreters more pleasant.

Author: odersky

library/src/scala/quoted/Expr.scala

@@ -4,3 +4,8 @@ class Expr[T] extends Quoted {
   def unary_~ : T = ???
   def run: T = ???
 }
+
+object Expr {
+  implicit def toExpr[T](x: T)(implicit ev: Quotable[T]): Expr[T] =
+    ev.toExpr(x)
+}

library/src/scala/quoted/Quotable.scala

@@ -0,0 +1,20 @@
+package scala.quoted
+import scala.math
+
+/** A typeclass for types that can be turned to `quoted.Expr[T]`
+ *  without going through an explicit `'(...)` operation.
+ */
+abstract class Quotable[T] {
+  implicit def toExpr(x: T): Expr[T]
+}
+
+/** Some base quotable types. To be completed with at least all types
+ *  that are valid Scala literals. The actual implementation of these
+ *  typed could be in terms of `ast.tpd.Literal`; the test `quotable.scala`
+ *  gives an alternative implementation using just the basic staging system.
+ */
+object Quotable {
+
+  implicit def IntIsQuotable: Quotable[Int] = ???
+  implicit def BooleanIsQuotable: Quotable[Boolean] = ???
+}

library/src/scala/quoted/Type.scala

@@ -4,3 +4,8 @@ class Type[T] extends Quoted {
   type unary_~ = T
 }
 
+/** Some basic type tags, currently incomplete */
+object Type {
+  implicit def IntTag: Type[Int] = new Type[Int]
+  implicit def BooleanTag: Type[Boolean] = new Type[Boolean]
+}

tests/pos/quotable.scala

@@ -0,0 +1,28 @@
+import scala.quoted._
+
+object Test {
+
+  implicit def IntIsQuotable: Quotable[Int] = new {
+    def toExpr(n: Int): Expr[Int] = n match {
+      case Int.MinValue    => '(Int.MinValue)
+      case _ if n < 0      => '(-(~toExpr(n)))
+      case 0               => '(0)
+      case _ if n % 2 == 0 => '( ~toExpr(n / 2) * 2)
+      case _               => '( ~toExpr(n / 2) * 2 + 1)
+    }
+  }
+
+  implicit def BooleanIsQuotable: Quotable[Boolean] = new {
+    implicit def toExpr(b: Boolean) =
+      if (b) '(true) else '(false)
+  }
+
+  implicit def ListIsQuotable[T: Type: Quotable]: Quotable[List[T]] = new {
+    def toExpr(xs: List[T]): Expr[List[T]] = xs match {
+      case x :: xs1 => '{ ~implicitly[Quotable[T]].toExpr(x) :: ~toExpr(xs1) }
+      case Nil => '(Nil: List[T])
+    }
+  }
+
+  val xs: Expr[List[Int]] = 1 :: 2 :: 3 :: Nil
+}

tests/pos/stagedInterpreter.scala

@@ -0,0 +1,22 @@
+import scala.quoted._
+
+enum Exp {
+  case Num(n: Int)
+  case Plus(e1: Exp, e2: Exp)
+  case Var(x: String)
+}
+
+object Test {
+  import Exp._
+
+  val exp = Plus(Plus(Num(2), Var("x")), Num(4))
+
+  def compile(e: Exp, env: Map[String, Expr[Int]]): Expr[Int] = e match {
+    case Num(n) => n
+    case Plus(e1, e2) => '(~compile(e1, env) + ~compile(e2, env))
+    case Var(x) => env(x)
+  }
+
+  val res = (x: Int) => ~compile(exp, Map("x" -> '(x)))
+
+}