Better castTo

Author: loverdos

src/main/scala/com/ckkloverdos/manifest/ManifestHelpers.scala

@@ -0,0 +1,62 @@
+package com.ckkloverdos.manifest
+
+/**
+ * Work in progress for obtaining a manifest dynamically.
+ *
+ * @author Christos KK Loverdos <loverdos@gmail.com>.
+ */
+object ManifestHelpers {
+  def manifestOfClass[T](clazz: Class[T]): Manifest[_ <: AnyRef] = {
+    if(clazz.isArray) {
+      Manifest.arrayType(manifestOfClass(clazz.getComponentType))
+    } else {
+      Manifest.classType(clazz)
+    }
+  }
+
+  def manifestOfAny[A](any: A): Manifest[_ <: Any] = {
+    any match {
+      case byte: Byte =>
+        Manifest.Byte
+      case byte: Boolean =>
+        Manifest.Boolean
+      case short: Short =>
+        Manifest.Short
+      case byte: Char =>
+        Manifest.Char
+      case any: Int =>
+        Manifest.Int
+      case long: Long =>
+        Manifest.Long
+      case float: Float =>
+        Manifest.Float
+      case double: Double =>
+        Manifest.Double
+      case unit: Unit =>
+        Manifest.Unit
+
+//      case byte: java.lang.Byte =>
+//        Manifest.Byte
+//      case byte: java.lang.Boolean =>
+//        Manifest.Boolean
+//      case short: java.lang.Short =>
+//        Manifest.Short
+//      case byte: java.lang.Character =>
+//        Manifest.Char
+//      case any: java.lang.Integer =>
+//        Manifest.Int
+//      case long: java.lang.Long =>
+//        Manifest.Long
+//      case float: java.lang.Float =>
+//        Manifest.Float
+//      case double: java.lang.Double =>
+//        Manifest.Double
+
+      case null =>
+        Manifest.Null
+
+      case anyRef: AnyRef =>
+        manifestOfClass(anyRef.getClass)
+    }
+  }
+}

src/main/scala/com/ckkloverdos/maybe/Maybe.scala

@@ -17,6 +17,7 @@
 package com.ckkloverdos.maybe
 
 import collection.Iterator
+import com.ckkloverdos.manifest.ManifestHelpers
 
 /**
  * Inspired by Lift's `Box`, Haskell's `Maybe` and Scala's `Option`.
@@ -86,7 +87,7 @@ sealed abstract class Maybe[+A] extends Serializable {
   final def foldJust[T](onJust: (A) ⇒ T)(onOther: ⇒ T): T =
     fold(onJust)(onOther)(f ⇒ onOther)
 
-  def castTo[B <: AnyRef : Manifest]: Maybe[B]
+  def castTo[B : Manifest]: Maybe[B]
 
   /**
    * Flattens two successive maybes to one.
@@ -188,13 +189,19 @@ final case class Just[+A](get: A) extends MaybeOption[A] with MaybeEither[A] {
   }
   def foreach(f: A ⇒ Unit) = f(get)
 
-  def castTo[B <: AnyRef : Manifest] = get match {
-    case null ⇒ NoVal
-    case value if(manifest[B].erasure.isInstance(value)) ⇒ this.asInstanceOf[Maybe[B]]
-    case value ⇒ Failed(
-      new ClassCastException("%s -> %s".format(
-        get.asInstanceOf[AnyRef].getClass.getName,
-        manifest[B].erasure.getName)))
+  def castTo[B : Manifest] = get match {
+    case null ⇒
+      NoVal
+    case value ⇒ //if(manifest[B].erasure.isInstance(value)) ⇒ this.asInstanceOf[Maybe[B]]
+      val ma = ManifestHelpers.manifestOfAny(get)
+      val mb = manifest[B]
+      if(mb == ma || mb.erasure.isInstance(get))
+        this.asInstanceOf[Maybe[B]]
+      else
+        Failed(
+          new ClassCastException("%s -> %s".format(
+            get.asInstanceOf[AnyRef].getClass.getName,
+            manifest[B].erasure.getName)))
   }
 
   def flatten1[U](implicit ev: A <:< Maybe[U]): Maybe[U] = ev(get)
@@ -228,7 +235,7 @@ case object NoVal extends MaybeOption[Nothing] {
 
   def finallyFlatMap[B](_finally: (Nothing) ⇒ Unit)(f: (Nothing) ⇒ Maybe[B]) = this
 
-  def castTo[B <: AnyRef : Manifest] = this
+  def castTo[B : Manifest] = this
 
   def flatten1[U](implicit ev: <:<[Nothing, Maybe[U]]) = this
 
@@ -266,7 +273,7 @@ final case class Failed(exception: Throwable) extends MaybeEither[Nothing] {
 
   def finallyFlatMap[B](_finally: (Nothing) ⇒ Unit)(f: (Nothing) ⇒ Maybe[B]) = this
 
-  def castTo[B <: AnyRef : Manifest] = this
+  def castTo[B : Manifest] = this
 
   def flatten1[U](implicit ev: <:<[Nothing, Maybe[U]]) = this
 

src/test/scala/com/ckkloverdos/maybe/MaybeTest.scala

@@ -99,24 +99,30 @@ class MaybeTest {
   }
 
   @Test
-  def testCastTo: Unit = {
+  def testCastToCharSequenceSuccess: Unit = {
     val help = "Help"
     val aJust: Maybe[_] = Just(help)
     Assert.assertTrue(aJust.castTo[CharSequence].isJust)
   }
 
   @Test
-  def testCastTo2: Unit = {
+  def testCastToScalaObjectFailure: Unit = {
     val help = "Help"
     val aJust: Maybe[_] = Just(help)
     Assert.assertTrue(aJust.castTo[ScalaObject].isFailed)
   }
 
   @Test
-  def testCastTo3: Unit = {
+  def testCastToIntFailure: Unit = {
     Assert.assertTrue(Just(1).castTo[String].isFailed)
   }
 
+  @Test
+  def testCastToIntSuccess: Unit = {
+    val cast = Maybe(1).castTo[Int]
+    Assert.assertTrue(cast.isJust)
+  }
+
   @Test
   def testFinallyMap: Unit = {
     var _flag1 = false