Comment puis-je correspondre à une signature de fonction sans obtenir les avertissements du compilateur d'effacement de type à Scala

Question

Quelqu'un peut-il réécrire ce code pour faire la même chose, mais sans aucun avertissement du compilateur s'il vous plaît: -

object TestTypeErasure { 

    def main(args:Array[String]) { 

    def myFunction(myObject:Any):Boolean = { 
     true 
    } 

    val myVariable: (Any => Boolean) = myFunction 

    myVariable match { 
     case function:(Any => Boolean) => println("Match") 
    } 

    } 
} 

Mille thankyous

Keith

Mettre à jour !!!!. Désolé de faire un vrai hachage de ça. Sa première question sur le SO

Juste pour les gourous savent que je l'ai essayé quelque chose le long des lignes de cela aussi en vain: - (ne peut pas compiler)

object TestTypeErasure { 

    def doTest(parameter: Any) = { 
     parameter match { 
      case function:Function1[_, _] => function("Whatever") 
     } 
    } 

    def main(args:Array[String]) { 
    } 

} 

J'obtiens l'erreur: -

TestTypeErasure.scala:6: error: type mismatch; 
    found : java.lang.String("Whatever") 
    required: _ 
    case function:Function1[_, _] => function("Whatever") 
               ^
one error found 

Merci encore

Keith

Answer 1

Jetez un oeil à cette question : Pattern matching zero-argument functions in scala: mystified by warning

Answer 2

Vous pouvez capturer les informations de type avec Manifest. (T, R sont invariantes ici pour garder les choses simples.)

import scala.reflect._ 
def matchFunction[T,R](f: Function1[T,R], t : T)(implicit mt : Manifest[T], mr : Manifest[R]) = { 
    val result = if ((mt.erasure, mr.erasure) == (classOf[Any], classOf[Boolean])) "any, boolean " + f(t) 
    else if((mt.erasure, mr.erasure) == (classOf[Int], classOf[Int])) "int, int " + f(t) 
    else "Unknown " + f(t) 
    println(result) 
} 

scala>  matchFunction((x : Int) => x + 1, 1) 
int, int 2 

scala>  matchFunction((x : Any) => true, 1 : Any) 
any, boolean true 

scala>  matchFunction((x : Boolean) => ! x, false) 
Unknown 

Pour Scala 2.8, on peut utiliser des bornes de contexte, en supprimant les deux paramètres implicites:

import scala.reflect._ 
def matchFunction[T: Manifest,R : Manifest](f: Function1[T,R], t : T) = { 
    val mt = implicitly[Manifest[T]] 
    val mr = implicitly[Manifest[T]] 
    val result = if ((mt.erasure, mr.erasure) == (classOf[Any], classOf[Boolean])) "any, boolean " + f(t) 
    else if((mt.erasure, mr.erasure) == (classOf[Int], classOf[Int])) "int, int " + f(t) 
    else "Unknown " + f(t) 
    println(result) 
} 

Answer 3

Il existe une variété d'approches qui pourraient travail, dont aucun n'est aussi simple. Une option consiste à utiliser des manifestes, mais vous devez définir votre propre variante de correspondance qui était manifeste. Vous pouvez en savoir plus sur les manifestes here. Si vous devez souvent faire ce genre de chose, ce serait la bonne façon de procéder, bien que cette fonctionnalité soit toujours considérée comme expérimentale.

Une autre option, si votre utilisation est relativement légère, consiste à envelopper la fonction dans une classe qui n'est pas générique. Par exemple,

object Example { 
    def hasString(a:Any) = (a!=null && a.toString.length>0) 

    case class AnyImpliesBoolean(f: (Any) => Boolean) { } 
    implicit def callAIB(aib: AnyImpliesBoolean) = aib.f 

    def callWrapped(a: Any) { 
    a match { 
     case aib: AnyImpliesBoolean => println(aib("Check")) 
     case _ => println("(Nothing)") 
    } 
    } 

    def tryMe() { 
    val has = AnyImpliesBoolean(hasString _) 
    callWrapped(has) 
    callWrapped("foo") 
    callWrapped((s:String)=>true) 
    } 
} 

scala> Example.tryMe 
true 
(Nothing) 
(Nothing) 

Si vous envelopper plusieurs fonctions différentes, mais pas trop grand nombre d'entre eux, vous pouvez créer une classe de base WrappedFunction et ont des choses comme AnyImpliesBoolean étendent WrappedFunction. Cependant, une autre option consiste à ne pas passer les fonctions autour, mais à utiliser à la place la réflexion pour faire passer les méthodes java.lang.Methods. Les méthodes connaissent leurs types. Même avec de jolis emballages Scala, ça serait encore un peu maladroit (et ce n'est pas très performant).

(sous la direction d'ajouter le lien manifeste que je manquais.)