asInstance[T] mais avec Option[T] comme résultat

Question

Je dispose d'une instance et d'un type et je souhaite obtenir Some dans le cas où la coulée est possible et None si ce n'est pas le cas.

Actuellement, j'utilise ma propre implémentation :

def tryCast[T](o: Any)(implicit manifest: Manifest[T]): Option[T] = {
  val clazz = manifest.runtimeClass.asInstanceOf[Class[T]]
  if (clazz.isAssignableFrom(o.getClass)) {
    Some(o.asInstanceOf[T])
  } else {
    None
  }
}

Existe-t-il une méthode dans la bibliothèque standard que je puisse utiliser à la place ?

Answer 1

À ma connaissance, il n'existe pas d'implémentation standard de cette fonction. Vous devez utiliser votre propre implémentation. Cependant, il n'y a pas d'implémentation standard de cette fonction, Manifest est obsolète, et vous devriez utiliser ClassTag au lieu de cela. En outre, lorsqu'un ClassTag est présent, le compilateur vous permet d'utiliser la recherche de motifs au lieu de vérifier manuellement les classes.

def tryCast[To: ClassTag](x: Any): Option[To] = x match {
  case thing: To => Some(thing)
  case _ => None
}

La méthode ci-dessus peut également être écrite comme suit :

//            "To: ClassTag" desugars to this v parameter, but it has no name
def tryCast[To](x: Any)(implicit tag: ClassTag[To]): Option[To] = x match {
  case thing: To => Some(thing)
  case _ => None
}

Answer 2

Je ne suis pas sûr qu'il existe une telle fonction, mais vous pourriez utiliser Try ainsi que .toOption :

import scala.util.Try
val name: Any = "tyler"
val name: Any = "tyler"
val maybeString: Option[String] = Try(name.asInstanceOf[String]).toOption
val maybeInt = Try(name.asInstanceOf[Int]).toOption

println(maybeString)
println(maybeInt)

Sortie

Some(tyler)
None

Vous pouvez aller plus loin en créant un type amélioré avec une conversion implicite.

Answer 3

Vous voulez peut-être le TypeTag , comme :

def tryCast[A](o: A)(implicit tpe: Type, ta: TypeTag[A]): Option[A] = ta.tpe =:= tpe match {
      case true => Some(o)
      case false => None
}
implicit val tag = typeOf[Int]
val cast: Option[Int] = tryCast(1)
val cast2: Option[String] = tryCast("hello")
println(cast)
println(cast2)

Résultat :

>Some(1)
>None

implicit tpe: Type est la personne que vous recherchez type et utiliser ta: TypeTag[A] implicit TypeTag obtenir votre type de paramètre.

de cette manière, aucun cast plus sûr.