Comment spécialiser un argument de type paramétré à plusieurs types différents dans Scala?

Question

J'ai besoin d'un contrôle de retour (s'il vous plaît).

Dans un article (http://www.win-vector.com/blog/2010/06/automatic-differentiation-with-scala/) je viens d'écrire que j'ai déclaré que je crois en Scala que vous ne pouvez pas spécifier une fonction qui prend un argument qui est lui-même une fonction avec un paramètre de type non lié. J'ai modifié cette question pour essayer de simplifier l'exemple.

Le code suivant fonctionne en introduisant un trait GenericFn qui imite le trait Scala Fonction1, sauf qu'il a un paramètre de type libre dans la fonction:

object TypeExample { 
    trait NumberBase { 
     def result:String 
    } 

    class A extends NumberBase { 
     def result = "A" 
    } 

    class B extends NumberBase { 
     def result = "B" 
    } 

    trait GenericFn { 
     def apply[X<:NumberBase](x:X):String 
    } 

    def specializeAndApplyTwice(f:GenericFn):String = { 
     f[A](new A()) + f[B](new B()) 
    } 

    def main(args : Array[String]) : Unit = { 
     val f = new GenericFn { 
      def apply[X<:NumberBase](x:X):String = { x.result } 
     } 
     println(specializeAndApplyTwice(f)) 
    } 
} 

Cela fonctionne, mais est-il un moyen de le faire sans le trait GenericFn (utiliser une notation de fonction standard)? Par exemple, le code échoue ci-dessous avec l'erreur de compilation: "incompatibilité de type Trouvée: TypeExample2.A requis: _ 1 $ _ où type 1 < $: TypeExample2.NumberBase":

def specializeAndApplyTwice(f:(_<:NumberBase)=>String):String = { 
    f(new A()) + f(new B()) 
} 

Answer 1

Reformuler la motivation initiale du question: Nous voulons donner un type à valeur 'g' parce que nous voulons le faire circuler. Les valeurs Scala (bien sûr) ne peuvent pas avoir de type polymorphique, même s'il s'agit de valeurs de fonction. Alors, comment donner un type dont une partie est inconnue?

Je crois donc une solution consiste à utiliser des caractères génériques (une forme d'abstraction existentielle):

    def g(f: Array[_ <: NumberBase[_]] => Double, z: Array[Double]): Double 

L'explication de la prose pour le type de g est: une fonction de Array [T] et Array [Double] à Double, où T est un certain type qui s'étend double. "un peu" est le mot qui indique l'abstraction existentielle, nous demandons qu'un tel type existe bien que nous ne nous soucions pas de ce que c'est.