claireneveu / macrame Goto Github PK

  object Foo {
    def setType(t: scala.reflect.api.Types#Type): Unit = ???
  }
  object Bar {
    @delegate def foo: Foo.type = Foo
  }

class F {
  def dslBuffer(seq: Seq[Int]): Unit = ???
}

object O {
  @delegate
  val f: F = new F
}

sealed trait Foo
case class Bar(i : Int) extends Foo
case class Baz(s : String) extends Foo
val foo : Foo = Bar(5)

def barF(b : Bar) : String = b.i
def bazF(b : Baz) : String = b.s

foo.autoFold(barF _, bazF _)

foo.autoFold(bazF _, barF _)

foo match {
  case b @ Bar(_) => barF(b)
  case b @ Baz(_) => bazF(b)
}

package myPackage

import macrame.delegate

object Foo {

  val s = ""

}

object Bar {

  @delegate
  val underlying: Foo.type = Foo

}

object Main {

  def main(args: Array[String]): Unit = {
    val s1: Foo.s.type = Foo.s
    val s2: Bar.s.type = Bar.s
    assert(s1 eq s2)
  }
}

trait EnumAsString[Enum] { self: EnumApi[Enum] =>
  def asString(e : Enum) : String = asStringImpl(e)
}

package myPackage

import macrame.delegate

object Foo {

  type AnySeq = Seq[_]

  def emptySeq: AnySeq = Nil

}

object Bar {

  @delegate
  val underlying: Foo.type = Foo

}

object Main {

  def main(args: Array[String]): Unit = {
    val x: AnySeq = Bar.emptySeq
  }
}

package myPackage

import macrame.delegate

object Foo {

  object O

}

object Bar {

  @delegate
  val underlying: Foo.type = Foo

}

object Main {

  def main(args: Array[String]): Unit = {
    val o1 = Foo.O
    val o2 = Bar.O
    assert(o1 eq o2)
  }
}

// In User.scala
@delegatable
case class User(name : String, password : String)
// in WithDbMeta.scala
case class WithDbMeta[A](id : Id[A], updateTime : DateTime, @delegate underlying : A)

// In User.scala
case class User(name : String, password : String)
object User {
  object delegates {
    <UserLike typeclass, ops class, extension implementation, etc>
  }
}
// in WithDbMeta.scala
case class WithDbMeta[A](id : Id[A], updateTime : DateTime, @delegate underlying : A)
object WithDbMeta {
  // We would check that `T` extends some dummy trait here to perform a fast exit if this isn't delegate related. Otherwise, we try to generate the appropriate instance, using whitebox macros to fail gracefully if we have the wrong type.
  implicit def delegateInstance[T[_], A]: T[WithDbMeta[A] = macro impl
}

Welcome to Scala version 2.10.6 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_102).
Type in expressions to have them evaluated.
Type :help for more information.

scala> object Foo {
     |   implicit final class RichAnyRef[A](val underlying: A) {
     |     def get: A = underlying
     |   }
     | }
defined module Foo

scala> object Bar {
     |   @macrame.delegate
     |   def foo: Foo.type = Foo
     | }
defined module Bar

scala> Bar.RichAnyRef("xxx")
res2: Foo.RichAnyRef[String] = Foo$RichAnyRef@4f05610e

scala> import Bar.RichAnyRef
import Bar.RichAnyRef

scala> RichAnyRef("xxx").get
res3: String = xxx

scala> "xxx".get
<console>:11: error: value get is not a member of String
              "xxx".get
                    ^

scala> new RichAnyRef("xxx").get
<console>:11: error: not found: type RichAnyRef
              new RichAnyRef("xxx").get
                  ^

object Post {
   final case class Byline()
}

final case class CleanPost(byline : Option[Post.Byline] = None)

final case class Post(@delegate clean : CleanPost)