seraphr

TypeMember使って実装したGraph

generics版 https://gist.github.com/seraphr/6858351

seraphr

Generics使って実装したGraph

TypeMember版 https://gist.github.com/seraphr/6858219

seraphr

trait Hoge{def hoge: String}
def h(a: Hoge) = a.hoge

val hogeInstance: Hoge = new Hoge{def hoge = "hoge"}
val hogeLikeInstance: {def hoge: String} = new {def hoge = "fuga"}

h(hogeInstance) // OK
h(hogeLikeInstance) // NG

seraphr

import scala.reflect.runtime.universe._

class TypeCheck[T: WeakTypeTag]{
  
  val mClassType = implicitly[WeakTypeTag[T]].tpe
  val mConstructors = mClassType.members.filter(_.isMethod).map(_.asMethod).filter(_.isConstructor)
  val mConstructorsParams = mConstructors.map(_.paramss.flatten.map(_.typeSignature))

  def of[A: WeakTypeTag](a: A): Boolean = {

seraphr

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

object InitializeMacro{
  def init[T, A, B](a: A, b: B) = macro initImpl[T, A, B]

  def initImpl[T: c.WeakTypeTag, A: c.WeakTypeTag ,B: c.WeakTypeTag](c: Context)(a: c.Expr[A], b: c.Expr[B]): c.Expr[T] = {
    import c.universe._

    val tType = implicitly[WeakTypeTag[T]].tpe

seraphr

scala> case class Base(id: String, data: String)
defined class Base

scala> case class Merged(id: String, dataList: Seq[String])
defined class Merged

scala>

scala> val tSeq = Seq(Base("c", "c2"), Base("a", "a1"), Base("c", "c3"), Base("a", "a2"), Base("b", "b"), Base("c", "c1"))
tSeq: Seq[Base] = List(Base(c,c2), Base(a,a1), Base(c,c3), Base(a,a2), Base(b,b), Base(c,c1))

seraphr

def foldRightSimple[A, B](l: List[A])(z: B)(f: (A, B) => B): B = l match {
  case Nil => z
  case x :: xs => f(x, foldRightSimple(xs)(z)(f))
}

trait Trampoline[T]
case class Done[T](v: T) extends Trampoline[T]
case class Suspend[T](f: () => Trampoline[T]) extends Trampoline[T]

@annotation.tailrec

seraphr

trait Tree[A]
case class Leaf[A](v: A) extends Tree[A]
case class Branch[A](l: Tree[A], r: Tree[A]) extends Tree[A]


def fold[A, B](t: Tree[A])(map: A => B, construct: (B, B) => B): B = t match {
  case Leaf(v) => map(v)
  case Branch(l, r) => construct(fold(l)(map, construct), fold(r)(map, construct))
}

seraphr

def traverse[A, B](a: List[A])(f: A => Option[B]): Option[List[B]] = a match {
  case x :: xs => 
    for {
      y <- f(x)
      ys <- traverse(xs)(f)
    } yield y :: ys
  case _ =>
    Some(Nil)
}

seraphr

def foldRight[A, B](s: Stream[A])(z: => B)(f: (A, => B) => B): B = s match {
  case x #:: xs => f(x, foldRight(xs)(z)(f))
  case _ => z
}

def headOptionViaFoldRight[A](s: Stream[A]): Option[A] = foldRight(s)(None: Option[A]) {
  (e, acc) => Some(e)
}

def map[A, B](s: Stream[A])(f: A => B): Stream[B] = foldRight(s)(Stream.empty[B]) {