add value support

Author: Oron Port

src/main/scala/singleton/ops/OpIntercept.scala

@@ -3,7 +3,7 @@ import impl._
 
 import scala.annotation.implicitNotFound
 @implicitNotFound("Missing an `OpIntercept` implicit for the operation ${Op}")
-trait OpIntercept[Op <: HasOut] extends HasOut
+trait OpIntercept[Op <: HasOut] extends HasOutValue
 object OpIntercept {
   type Aux[Op <: HasOut, Out0] = OpIntercept[Op]{type Out = Out0}
 }

src/main/scala/singleton/ops/impl/GeneralMacros.scala

@@ -915,7 +915,7 @@ trait GeneralMacros {
           silent = false
         )
         TypeCalc(itree.tpe.decls.head.info) match {
-          case t : CalcUnknown => t.copy(opIntercept = true) //the unknown result must be marked properly so we allow it later
+          case t : CalcUnknown => t.copy(treeOption = Some(c.untypecheck(q"$itree.value")),opIntercept = true) //the unknown result must be marked properly so we allow it later
           case t => t
         }
       } catch {

src/test/scala/singleton/ops/OpInterceptSpec.scala

@@ -6,33 +6,41 @@ import singleton.TestUtils._
 
 class OpInterceptSpec extends Properties("OpInterceptSpec") {
 
-  trait Vec[A0, A1]
+  trait Vec[A0, A1] {
+    def show(implicit a0 : ValueOf[A0], a1 : ValueOf[A1]) : String = s"Vec[${valueOf[A0]}, ${valueOf[A1]}]"
+  }
 
   implicit def `Vec+`[VL0, VL1, VR0, VR1](
     implicit
     opL : VL0 + VR0,
     opR : VL1 + VR1
-  ) : OpIntercept.Aux[Vec[VL0, VL1] + Vec[VR0, VR1], Vec[opL.Out, opR.Out]] = ???
+  ) : OpIntercept.Aux[Vec[VL0, VL1] + Vec[VR0, VR1], Vec[opL.Out, opR.Out]] = //Vec is not a singleton value, so we need to instantiate OpIntercept
+    new OpIntercept[Vec[VL0, VL1] + Vec[VR0, VR1]] {
+      type Out = Vec[opL.Out, opR.Out]
+      val value : Out = new Vec[opL.Out, opR.Out]{}
+    }
 
   implicit def `Vec==`[VL0, VL1, VR0, VR1](
     implicit
     op : (VL0 == VR0) && (VL1 == VR1)
-  ) : OpIntercept.Aux[Vec[VL0, VL1] == Vec[VR0, VR1], op.Out] = ???
+  ) : OpIntercept.Aux[Vec[VL0, VL1] == Vec[VR0, VR1], op.Out] = ??? //No need to instantiate when a singleton value is returned
 
-  property("Custom Vec Equality OK") = wellTyped {
+  property("Custom Vec Equality OK") = {
     val eq1 = shapeless.the[Vec[W.`1`.T, W.`2`.T] == Vec[W.`1`.T, W.`2`.T]]
     val eq2 = shapeless.the[Vec[W.`1`.T, W.`2`.T] == Vec[W.`1`.T, W.`1`.T]]
     implicitly[eq1.Out =:= W.`true`.T]
     implicitly[eq2.Out =:= W.`false`.T]
+    eq1.value == true
   }
 
-  property("Custom Vec Addition OK") = wellTyped {
+  property("Custom Vec Addition OK") = {
     val add2 = shapeless.the[Vec[W.`1`.T, W.`2`.T] + Vec[W.`3`.T, W.`8`.T]]
     val add3 = shapeless.the[Vec[W.`1`.T, W.`2`.T] + Vec[W.`3`.T, W.`8`.T] + Vec[W.`20`.T, W.`20`.T]]
     implicitly[add2.Out =:= Vec[W.`4`.T, W.`10`.T]]
     implicitly[add3.Out =:= Vec[W.`24`.T, W.`30`.T]]
     val add23 = shapeless.the[add2.Out + add3.Out]
     implicitly[add23.Out =:= Vec[W.`28`.T, W.`40`.T]]
+    add2.value.show == "Vec[4, 10]"
   }
 
 
@@ -41,13 +49,14 @@ class OpInterceptSpec extends Properties("OpInterceptSpec") {
   implicit def doFib[P](
     implicit
     op : ITE[P == W.`0`.T, W.`0`.T, ITE[P == W.`1`.T, W.`1`.T, Fib[P - W.`1`.T] + Fib[P - W.`2`.T]]]
-  ) : OpIntercept.Aux[Fib[P], op.Out] = ???
+  ) : OpIntercept.Aux[Fib[P], op.Out] = ??? //No need to instantiate when a singleton value is returned
 
-  property("Custom Fibonacci Op OK") = wellTyped {
+  property("Custom Fibonacci Op OK") = {
     val fib4 = shapeless.the[Fib[W.`4`.T]]
     implicitly[fib4.Out =:= W.`3`.T]
     val fib10 = shapeless.the[Fib[W.`10`.T]]
     implicitly[fib10.Out =:= W.`55`.T]
+    fib10.value == 55
   }