Est-il possible dans Scala de forcer l'appelant à spécifier un paramètre de type pour une méthode polymorphe?

Question

Dans le code ci-dessus, le site client "a oublié" de spécifier le paramètre de type, car l'éditeur d'API I veut pour signifier "juste retourner un nœud". Existe-t-il un moyen de définir une méthode générique (pas une classe) pour atteindre cet objectif (ou l'équivalent)? Note: en utilisant un manifeste dans l'implémentation pour faire la distribution si (manifeste! = Scala.reflect.Manifest.Nothing) ne compile pas ... J'ai le sentiment lancinant que certains Scala Wizard savent utiliser Predef. <: < pour cela :-)

Idées?

Answer 1

Une autre solution consiste à spécifier un type par défaut pour le paramètre comme suit:

object Finder { 
    def find[T <: Node](name: String)(implicit e: T DefaultsTo Node): T = 
     doFind(name).asInstanceOf[T] 
} 

La clé est de définir le type fantôme suivant d'agir comme témoin pour la valeur par défaut:

sealed class DefaultsTo[A, B] 
trait LowPriorityDefaultsTo { 
    implicit def overrideDefault[A,B] = new DefaultsTo[A,B] 
} 
object DefaultsTo extends LowPriorityDefaultsTo { 
    implicit def default[B] = new DefaultsTo[B, B] 
} 

L'avantage de cette approche est qu'elle évite complètement l'erreur (à la fois à l'exécution et à la compilation). Si l'appelant ne spécifie pas le paramètre de type, il est par défaut Node.

Explication:

La signature de la méthode find assure qu'elle ne peut être appelé si l'appelant peut fournir un objet de type DefaultsTo[T, Node]. Bien sûr, les méthodes default et overrideDefault facilitent la création d'un tel objet pour tout type T. Étant donné que ces méthodes sont implicites, le compilateur gère automatiquement l'appel de l'une d'elles et transmet le résultat dans find.

Mais comment le compilateur sait-il quelle méthode appeler? Il utilise ses règles d'inférence de type et de résolution implicite pour déterminer la méthode appropriée. Il y a trois cas à considérer:

1. find est appelée sans paramètre de type. Dans ce cas, le type T doit être déduit. En recherchant une méthode implicite qui peut fournir un objet de type DefaultsTo[T, Node], le compilateur trouve default et overrideDefault. default est choisi car il est prioritaire (car il est défini dans une sous-classe propre du trait qui définit overrideDefault). Par conséquent, T doit être lié à Node.

2. find est appelé avec un paramètre de type non Node (par exemple, find[MyObj]("name")). Dans ce cas, un objet de type DefaultsTo[MyObj, Node] doit être fourni. Seule la méthode overrideDefault peut le fournir, de sorte que le compilateur insère l'appel approprié.

3. find est appelé avec Node comme paramètre de type. Encore une fois, l'une ou l'autre méthode est applicable, mais default gagne en raison de sa priorité plus élevée.

Answer 2

Il est possible d'obtenir ce que vous recherchez, mais ce n'est pas simple. Le problème est que sans un paramètre de type explicite, le compilateur peut seulement déduire que T est Nothing. Dans ce cas, vous voulez find pour retourner quelque chose de type Node, pas de type T (à savoir Nothing), mais dans tous les cas, vous voulez trouver quelque chose pour revenir de type T.

Lorsque vous souhaitez que votre type de retour varie en fonction d'un paramètre de type, vous pouvez utiliser une technique similaire à celle que j'ai utilisée dans method lifting API.

object Finder { 
    def find[T <: Node] = new Find[T] 

    class Find[T <: Node] { 
     def apply[R](name: String)(implicit e: T ReturnAs R): R = 
      doFind(name).asInstanceOf[R] 
    } 

    sealed class ReturnAs[T, R] 
    trait DefaultReturns { 
     implicit def returnAs[T] = new ReturnAs[T, T] 
    } 
    object ReturnAs extends DefaultReturns { 
     implicit object returnNothingAsNode extends ReturnAs[Nothing, Node] 
    } 
} 

Ici, le procédé find retourne un foncteur polymorphe qui, lorsqu'elle est appliquée à un nom, retourne un objet de chaque type ou de type TNode en fonction de la valeur de l'argument ReturnAs fourni par le compilateur. Si T est Nothing, le compilateur fournira l'objet returnNothingAsNode et la méthode apply retournera un Node. Sinon, le compilateur fournira un ReturnAs[T, T] et la méthode apply retournera un T.

---

Riffing au large de la solution de Paul sur la liste de diffusion, une autre possibilité est de fournir un implicite pour chaque type qui « fonctionne ». Au lieu de retourner un Node lorsque le paramètre de type est omis, une erreur de compilation sera émis:

object Finder { 
    def find[T : IsOk](name: String): T = 
     doFind(name).asInstanceOf[T] 

    class IsOk[T] 
    object IsOk { 
     implicit object personIsOk extends IsOk[Person] 
     implicit object nodeIsOk extends IsOk[Node] 
    } 
} 

Bien sûr, cette solution n'échelle pas bien.

Answer 3

La solution de Paul fournit une borne inférieure sur T, donc val person = find ("joe") est une erreur de compilation, vous obligeant à indiquer explicitement le type (par exemple, Node). Mais c'est une solution plutôt affreuse (Paul a explicitement dit qu'il ne le recommandait pas), car il vous oblige à énumérer tous vos sous-types.

Answer 4

Miles Sabin posted a really nice solution pour ce problème dans la liste de diffusion scala-user.Définir une classe de type NotNothing comme suit:

sealed trait NotNothing[T] { type U }           
object NotNothing { 
    implicit val nothingIsNothing = new NotNothing[Nothing] { type U = Any } 
    implicit def notNothing[T] = new NotNothing[T] { type U = T }   
} 

Maintenant, vous pouvez définir votre Finder comme

object Finder { 
    def find[T <: Node : NotNothing](name: String): T = 
     doFind(name).asInstanceOf[T] 
} 

Si vous essayez d'appeler Finder.find sans paramètre de type, vous obtiendrez une erreur de compilation:

error: ambiguous implicit values: both method notNothing in object $iw of type [T]java.lang.Object with NotNothing[T]{type U = T} and value nothingIsNothing in object $iw of type => java.lang.Object with NotNothing[Nothing]{type U = Any} match expected type NotNothing[T] Finder.find("joe")

Cette solution est beaucoup plus générale que celles proposées dans mes autres réponses. Le seul inconvénient que je peux voir est que l'erreur de compilation est assez opaque, et l'annotation @implicitNotFound n'aide pas.