typerep.scala

JAVA 语言的函数式编程扩展

//############################################################################
// Type Representation at runtime
//############################################################################
// $Id:  $

import TypeRep._

object Test extends Application {
  testPrimitives
  testOptions
  testLists
  testArrays
  testTuples
  testFuncs
  testClasses
}

object serialize {
  import java.io._

  @throws(classOf[IOException])
  def write[A](o: A): Array[Byte] = {
    val ba = new ByteArrayOutputStream(512)
    val out = new ObjectOutputStream(ba)
    out.writeObject(o)
    out.close()
    ba.toByteArray()
  }
  @throws(classOf[IOException])
  @throws(classOf[ClassNotFoundException])
  def read[A](buffer: Array[Byte]): A = {
    val in =
      new ObjectInputStream(new ByteArrayInputStream(buffer))
    in.readObject().asInstanceOf[A]
  }
}

object testPrimitives {
  println(getType(true))
  val b = false; val bt = getType(b)
  println(bt)
  val bt1: TypeRep[Boolean] = serialize.read(serialize.write(bt))
  println(bt1 == bt)
  println(getType(16.toByte))
  println(getType('a'))
  println(getType(3))
  println(getType(3l))
  println(getType(0.0f))
  println(getType(0.0d))
  println(getType("abc"))
  println(getType(())) // Unit
//  println(getType(classOf[Int])) // Class
  println
}

object testOptions {
  println(getType(Some(2)))
  val x: Option[Int] = Some(2)
  println(getType(x))
  println(getType(Some(Some(3))))
  println(getType(None))
  val y: Option[Int] = None
  println(getType(y))
  println
}

object testLists {
  println(getType(List(3)))
  println(getType(3 :: Nil))
  println(getType(List(List(3))))
  println(getType(Nil))
  println(getType(List(1, "abc")))
  println
}

object testArrays {
  println(getType(Array(3)))
  println(getType(Array(Array(3), Array(4))))
  println(getType(new Array[Int](0)))
  println(getType(List(1).toArray))
  println(getType(List[Int]().toArray))
  println(getType(Array(3).drop(1).toArray)) // empty
  println
}

object testTuples {
  println(getType((3, "abc")))
  println(getType(Triple('a', 'b', "c")))
  println(getType(((3, "abc"), (4, "xyz"))))
  println(getType(((Some('b'), 3), (Some('a'), 4))))
  //println(getType(((Some('b'), 3), (None, 4))))
  println
}

object testFuncs {
  def f1(x: Int): Int = 2 * x
  println(getType(f1 _))
  println(getType(f1(2)))
  val f2 = (x: Int) => 2 * x
  println(getType(f2))
  println(getType(f2(2)))
  val f3 = (x: Int) => (y: Int) => x + y
  println(getType(f3))
  println(getType(f3(2)))
  println(getType(f3(2)(2)))
  def f4(b: Boolean, c: List[Char], i: Int): Int = i
  println(getType(f4 _))
  def f5(f: Int => Int, x: Int) = f(x)
  println(getType(f5 _))
  println(getType(f5(f1, 1)))
  println  
}

class Foo {
  class Bar(x: Int)
}


object foo extends Foo

package pkg1 {
  class C1
  object c1 extends C1
}

object testClasses {
  /*
  case object FooRep extends TypeRep[Foo] {
    override def toString = "Foo"
  }
  implicit def fooRep[A](x: A)(implicit rep: TypeRep[foo.type]): TypeRep[foo.type] = rep
  println(getType(foo))
  println(getType(new foo.Bar(0)))
  val foo2 = new Foo
  println(getType(foo2))
  println(getType(new foo2.Bar(1)))
  println

  println(getType(pkg1.c1))
  val c1 = new pkg1.C1
  println(getType(c1))
  println
  */
}


/**
 *  @author Stephane Micheloud
 *  @version 1.0
 */
abstract class TypeRep[A]

object TypeRep {

  def getType[A](x: A)(implicit rep: TypeRep[A]): TypeRep[A] = rep

  def getType[A](x: Option[A])(implicit rep: TypeRep[A]): TypeRep[Option[A]] = (x match {
    case Some(v) => SomeRep(rep)
    case None    => NoneRep // or NoneRep(rep)
  }).asInstanceOf[TypeRep[Option[A]]]

  def getType[A](x: List[A])(implicit rep: TypeRep[A]): TypeRep[List[A]] = (x match {
    case h :: t => ListRep(getType(h))
    case Nil    => NilRep
  }).asInstanceOf[TypeRep[List[A]]]

  implicit def boolRep: TypeRep[Boolean] = BooleanRep
  implicit def byteRep: TypeRep[Byte] = ByteRep
  implicit def charRep: TypeRep[Char] = CharRep
  implicit def shortRep: TypeRep[Short] = ShortRep
  implicit def intRep: TypeRep[Int] = IntRep
  implicit def longRep: TypeRep[Long] = LongRep
  implicit def floatRep: TypeRep[Float] = FloatRep
  implicit def doubleRep: TypeRep[Double] = DoubleRep

  implicit def unitRep: TypeRep[Unit] = UnitRep
//  implicit def classRep: TypeRep[Class] = ClassRep
  implicit def stringRep: TypeRep[String] = StringRep
  implicit def noneRep: TypeRep[Option[Nothing]] = NoneRep[Nothing](NothingRep.asInstanceOf[TypeRep[Nothing]])
  implicit def anyRep: TypeRep[Any] = AnyRep
  implicit def nothingRep: TypeRep[Nothing] = NothingRep

  implicit def someRep[A](implicit elemrep: TypeRep[A]): TypeRep[Some[A]] =
    SomeRep(elemrep)

  implicit def listRep[A](implicit elemrep: TypeRep[A]): TypeRep[List[A]] =
    ListRep(elemrep)