Les types d'arguments d'une fonction anonyme doivent être entièrement connus. (SLS 8.5)

{ case X(x) => ... } est une fonction partielle, mais le compilateur ne sait toujours pas quel est votre type d'entrée, sauf que c'est un supertype de X. Normalement ce n'est pas un problème parce que si vous écrivez une fonction anonyme, le type est connu du contexte. Mais voici comment vous pouvez fournir le type:

case class Foo(x: Int)

// via annotation
val f: Foo => Int = { case Foo(x) => x }

// use pattern matching
val f = (_: Foo) match { case Foo(x) => x }

// or more normally, write as a method
def f(a: Foo) = a match { case Foo(x) => x }
def f(a: Foo) = a.x

comme vous l'avez probablement remarqué, l'utilisation de la fonction correspondance littérales / motifs ici est assez inutile. Il semble dans votre cas que vous avez juste besoin d'un régulier méthode:

def whatever(qt: QualifiedType) = {
  t.ty = qt.ty
  Some((emptyEqualityConstraintSet, qt.preds)) 
}

bien que vous devriez réfléchir pour supprimer cet état mutable.

Voici pourquoi j'ai voulu utiliser une fonction littérale et n'ai pas aimé avoir à répéter le type deux fois. J'essayais de construire ma propre construction de contrôle pour éliminer toutes les options correspondant au code. S'il y a trop de frais généraux, alors la structure de contrôle n'aide pas. Voici ce que je voulais faire

//This is the control construct definition
def switch[A,B]( x : Option[A], noneFun : =>B, someFun : A=>B) = x match {
    case None => noneFun 
    case Some(y) => someFun(y) }

//And this is an example of using it.
def foobar( qt : Option[QualifiedType]  ) = 
    switch( qt, {reportError("SNAFU");None},
            {case QualifiedType(preds, ty) =>
               Some((emptyEqualityConstraintSet,preds)) } ) 

la construction de la commande d'interrupteur se compile bien, mais l'usage a causé une erreur parce que le SLS dit que là où j'ai un A, je devrais avoir un "type défini". C'est parce que ce genre de fonction littérale (le genre avec "cas") est destiné à des fonctions partielles où l'argument pourrait être légitimement n'importe quelle chose du tout. Je pourrais argumenter ma fonction littérale avec un int et ce ne serait pas une erreur de type, mais simplement une question de tous les modèles échouant. Donc le compilateur a besoin de quelques informations "top down" pour savoir quel type j'ai l'intention de mettre pour le paramètre de la "fonction étendue littérale", c'est-à-dire ce qu'il faut mettre pour X dans les

{(x : X) => x match {case Some(QualifiedType(preds, ty)) =>
               Some((emptyEqualityConstraintSet,preds)) } }

je me demande pourquoi le compilateur ne pouvait pas utiliser le type de commutateur pour voir que je n'ai pas l'intention d'une fonction partielle et puis unifier A avec QualifiedType. Mais ça ne marche pas.

de toute façon il ne compile pas. Mais remplacer A par Any élimine l'erreur. Le code suivant se compile. Ce que je perds, c'est une vérification de type.

//This is the control construct definition
def switch[A,B]( x : Option[A], noneFun : =>B, someFun : A=>B) = x match {
    case None => noneFun 
    case Some(y) => someFun(y) }

//And this is an example of using it.
def foobar( qt : Option[QualifiedType]  ) = 
    switch( qt, {reportError("SNAFU");None},
            {case QualifiedType(preds, ty) =>
               Some((emptyEqualityConstraintSet,preds)) } ) 

je serais intéressé de savoir (a) si la définition ci-dessus de commutateur peut être améliorée, et (b) s'il y a déjà une fonction de bibliothèque qui fait ce que je vouloir.

ajouté après le commentaire de Luigi

Voici le code final. Oui, je pense que c'est un pli (catamorphisme).

def switch[A,B]( x : Option[A])(noneFun : =>B, someFun : A=>B) = x match {
    case None => noneFun 
    case Some(y) => someFun(y) }

def foobar( qt : Option[QualifiedType]  ) : Option[(EqualityConstraintSet, TypeRelationSet)] =
    switch( qt )({reportError("SNAFU");None},
            {case QualifiedType(preds, ty) =>
               Some((emptyEqualityConstraintSet,preds)) } ) 

merci à Luigi.