Scala Carte pattern matching

Comment faire un patron sur un Map en Scala ?

Un (non-travail) tentative comprend,

Map("a"->1, "b"->2, "c"->3) match {
  case Map(a,b,_*) => a
}

qui tre avec

value Map is not a case class, nor does it have an unapply/unapplySeq member
              case Map(a,b,_*) => a

L'erreur est suffisamment explicites, mais comment enrichir Map avec un unapply méthode de filtrage ?

Merci Beaucoup

Mise à jour

Suivant @le commentaire de Paul, un plus soignée cas d'utilisation peut être comme cela,

Map("a"->1, "b"->2, "c"->3) match {
  case Map("b"->2,_*) => "222"
}

à savoir, dans ce cas, si la carte contient des mots-clés b que des cartes sur la valeur 2.

Pour votre exemple. est ce que vous voulez de match si la Carte contient une clé "a" et "b"? Il n'est pas clair pour moi ce que vous attendez de la Carte-pattern-matching à faire.
merci pour le commentaire, remarque la mise à jour.
OK. Maintenant, c'est un doublon de stackoverflow.com/questions/13536619/...

OriginalL'auteur elm | 2014-08-07

  1. 7

    Plus simple est tramsform Map à List:

    Map("a"->1, "b"->2, "c"->3).to[List] match {
  case List(a,b,_*) => a
}
    Merci une tonne, est l'ordre même de la transformation; d'autre peut-il devenir parfois de la Liste( ("a",1), (b,2), ... ) , et de la Liste( ("b",2), ("a",1), ... ) à d'autres moments ?
    les listes sont classées dans des collections scala de sorte qu'ils seront conformes à la commande que vous avez dans la carte.
    bon point, c'est effectivement la question, faire des cartes ont toute commande dans les clés, à savoir la Carte("a">1, "b"->2, "c"->3).keys offre Ensemble(a, b, c) sans annuler la méthode.
    Si vous avez un Map("a" -> 1, "b" ->2) et appel toList la liste aura le n-uplet dans le même ordre qu'à la Carte: List(("a", 1), ("b", 2)), Si vous avez la carte est Map("b" -> 1, "a" ->2), le toList méthode retourne: List(("b", 1), ("a", 2)), vous pouvez l'essayer aussi dans le REPL.
    Malgré @EndeNeu commentaire, je ne pense pas que les Cartes sont en général commandé.

    OriginalL'auteur Yuriy

  2. 2

    Une approche enrichissante Map avec un unapplySeq méthode de filtrage comprend cela,

    object MapExtractor {
  def unapplySeq[A <% Ordered[A], B <% Ordered[B]]
      (s: Map[A,B]): Option[Seq[(A,B)]] = Some(s.toSeq.sorted) 
}

    où le tri est une approche qui peut être changé à n'importe quel peut être commandé (éléments comparables) de la logique. Dans cet exemple,

    Map("b"->2, "a"->1, "c"->3) match {
  case MapExtractor ( x, xs @ _* ) => println(s"x: $x") ; println(s"xs: $xs") 
}

    offre

    x: (a,1)
xs: ArrayBuffer((b,2), (c,3))

    OriginalL'auteur elm