travisbrown

sealed trait Piece
case class Place(p: String) extends Piece
case class Name(n: String) extends Piece

case class LocatedPieces(located: Seq[(String, Piece, (Int, Int))])

object S2 extends ReflectionUtils {
  import scala.language.experimental.macros
  import scala.language.reflectiveCalls
  import scala.reflect.macros.Context

travisbrown

sealed trait Element
case class Tag(name: String, attr: String) extends Element
case class Header(text: String) extends Element
case class Plain(text: String) extends Element

import scala.util.parsing.combinator._

object parse extends RegexParsers {
  override def skipWhitespace = false
  def tag: Parser[Tag] = ("<" ~> "\\S+".r <~ "\\s".r) ~ "[^\\s>]+".r <~ ">" ^^ {

travisbrown

import shapeless._

type StringTo[X] = String => X

case class StringFunctions[H <: HList](functions: H = HNil: HNil) {
  def addFunction[T](f: StringTo[T]) = StringFunctions[StringTo[T] :: H](f :: functions)
  def map[H1 <: HList, R](f: H1 => R)(implicit mapped: MappedAux[H1, StringTo, H]) = ???
  def map2[T1, T2, R](f: (T1, T2) => R)(implicit ev: H <:< (StringTo[T1] :: StringTo[T2] :: _)) = ???
  def apply[S <: HList](strings: S)(implicit zip: ZipApply[H, S]) = zip(functions, strings)
}

travisbrown

scala> trait Foo { type X }
defined trait Foo

scala> implicit object foo extends Foo { type X = String }
defined module foo

scala> implicitly[Foo { type X = String }]
res0: Foo{type X = String} = foo$@6e1641c4

scala> implicitly[Foo]

travisbrown

object SplitBigMethod {
  val mapping = List.tabulate(10000)(i => (i, i + 1))
  val batchSize = 2000

  def lookup(i: Int): Int = macro lookup_impl
  def lookup_impl(c: Context)(i: c.Expr[Int]): c.Expr[Int] = {
    import c.universe._

    case class Batch(last: Int, name: TermName, definition: DefDef)

travisbrown

Suppose we want to lift an OptionT[List, Int] into a ReaderT[OptionT[List, _], String, Int]. The nice way (liftReaderT) currently doesn't work:

scala> List(1, 2, 3).liftM[OptionT].liftReaderT[String]
<console>:14: error: could not find implicit value for parameter F0: scalaz.UnapplyCo[scalaz.Monad,scalaz.OptionT[List,Int]]
              List(1, 2, 3).liftM[OptionT].liftReaderT[String]
                                 ^
<console>:14: error: value liftReaderT is not a member of scalaz.OptionT[List,Int]
              List(1, 2, 3).liftM[OptionT].liftReaderT[String]
 ^

travisbrown

<?xml version="1.0" encoding="UTF-8"?>
<project
  xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>demo</groupId>
  <artifactId>bar</artifactId>
  <name>Bar</name>
  <version>0.0.0</version>

travisbrown

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

object hlist {
  def apply(xs: Any*) = macro apply_impl

  def apply_impl(c: Context)(xs: c.Expr[Any]*) = {
    import c.universe._

travisbrown

object Trimmed {
  val Stop = ".*\\b(a|an|the|to|of|as|in|with|for)$".r
  val Fine = "(.+\\.)$".r
  val Punc = "(.+)[,;:]$".r
}

class Trimmed(size: Int) {
  def unapply(s: String) = s.replaceAll("\\s+", " ") match {
    case res if res.size <= size => Some(res)
    case res => res.split(' ').inits.map(_ mkString " ").flatMap {

travisbrown

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

object ImportExample {
  def demo = macro demo_impl

  def demo_impl(c: Context) = {
    import c.universe._

    def toQual(sym: Symbol): Tree = sym.owner.owner match {