travisbrown

import scala.language.experimental.macros
import scala.reflect.macros.Context
import shapeless._

object NatExample {
  def toNat(n: Int): Any = macro toNat_impl

  def toNat_impl(c: Context)(n: c.Expr[Int]) = {
    import c.universe._

travisbrown

trait ReflectionUtils {
  def constructor(u: scala.reflect.api.Universe) = {
    import u._

    DefDef(
      Modifiers(),
      nme.CONSTRUCTOR,
      Nil,
      Nil :: Nil,
      TypeTree(),

travisbrown

sealed trait Item
case class Marble() extends Item
case class Book() extends Item

sealed trait Container[Item]
case object Pouch extends Container[Marble]
case object Shelf extends Container[Book]

trait ContainerFor[I <: Item] { def apply(): Container[I] }
case class in[I <: Item](apply: Container[I]) extends ContainerFor[I]

travisbrown

scala> def foo[A, B, C](a: SNat[A], b: SNat[B], c: SNat[C])(implicit ssum: SSum[A, B, C]) = ssum
foo: [A, B, C](a: shapeless.SNat[A], b: shapeless.SNat[B], c: shapeless.SNat[C])(implicit ssum: shapeless.SSum[A,B,C])shapeless.SSum[A,B,C]

scala> foo(2, 3, 5)
res0: shapeless.SSum[Int(2),Int(3),Int(5)] = $anon$1@53d76e96

scala> foo(2, 3, 7)
<console>:15: error: could not find implicit value for parameter ssum: shapeless.SSum[Int(2),Int(3),Int(7)]
              foo(2, 3, 7)
                 ^

travisbrown

package example

import scala.language.experimental.macros
import scala.reflect.macros.{ Context, Macro }

trait SInt[I <: Int]

object SInt {
  implicit def materializeSInt[I <: Int](i: Int): SInt[I] =
    macro MaterializeSInt.expand[I]

travisbrown

object FooExample {
  sealed trait Foo {
    def i: Int
  }

  private case class SecretFoo(i: Int) extends Foo

  /* Without the explicit return type, we'd get this compiler error:
   *
   *     <console>:14: error: private class SecretFoo escapes its defining scope...

travisbrown

scala> import scala.language.experimental.macros
import scala.language.experimental.macros

scala> import scala.reflect.macros.{ Context, TypecheckException }
import scala.reflect.macros.{Context, TypecheckException}

scala> object NoncompilationTests {
     |   def compiles(code: _): Boolean = macro compiles_impl
     |   def compiles_impl(c: Context)(code: c.Tree) = c.literal(
     |     try {

travisbrown

import MyFuncMacro.myfunc

object MyFuncExample {
  def main(args: Array[String]) {
    val x: MyFunc[Int, Int] = myfunc { a: Int => a }
    println(x)
    println(x(42))
  }
}

travisbrown

import scala.language.experimental.macros
import scala.language.higherKinds
import scala.reflect.macros.Context

object MacroSAM {
  def sam[F[_, _], A, B](f: A => B) = macro sam_impl[F, A, B]
  
  def sam_impl[F[_, _], A: c.WeakTypeTag, B: c.WeakTypeTag](c: Context)
    (f: c.Expr[A => B])(implicit tag: c.WeakTypeTag[F[_, _]]) = {
    import c.universe._

travisbrown

// I'll assume you have something like the following:

import shapeless._

val fs = ((i: Int) => "a" * i) :: ((i: Int) => i + 42) :: HNil
val x = 3

// And you want this:

val result = "aaa" :: 45 :: HNil