Filtre de la Carte par un jeu de clés

Est-il un raccourci pour filtrer une Carte de conserver uniquement les entrées où la clé est contenue dans un Ensemble donné?

Voici un exemple de code

scala> val map = Map("1"->1, "2"->2, "3"->3)
map: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3)

scala> map.filterKeys(Set("1","2").contains)
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2)

Je suis à la recherche de quelque chose de plus court que cela.

Quelque chose de plus court que map.filterKeys(Set("1","2").contains)? Ne pensez-vous pas que c'est court et assez clair?
C'est assez clair, mais je suis à la recherche de quelque chose de plus court.
Et il peut être en effet! Voir ma réponse
Toujours à la recherche de quelque chose de plus clair et plus compréhensible pour plus tard, quand vous l'écrémage de votre code

InformationsquelleAutor Timo Westkämper | 2012-01-27

scala

De répondre à la Question

Vous pouvez profiter du fait qu'un Set[A] est un prédicat; c'est à dire A => Boolean

map filterKeys set

Ici, il est à l'œuvre:

scala> val map = Map("1" -> 1, "2" -> 2, "3" -> 3)
map: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3)

scala> val set = Set("1", "2")
set: scala.collection.immutable.Set[java.lang.String] = Set(1, 2)

scala> map filterKeys set
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2)

Ou si vous préférez:

scala> map filterKeys Set("1", "2")
res1: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2)

Prédicats

Il fait vraiment utile d'avoir quelques wrapper autour d'un prédicat. Comme:

scala> class PredicateW[A](self: A => Boolean) {
   | def and(other: A => Boolean): A => Boolean = a => self(a) && other(a)
   | def or(other: A => Boolean): A => Boolean = a => self(a) || other(a)
   | def unary_! : A => Boolean = a => !self(a)
   | }
defined class PredicateW

Et une conversion implicite:

scala> implicit def Predicate_Is_PredicateW[A](p: A => Boolean) = new PredicateW(p)
Predicate_Is_PredicateW: [A](p: A => Boolean)PredicateW[A]

Et puis vous pouvez l'utiliser:

scala> map filterKeys (Set("1", "2") and Set("2", "3"))
res2: scala.collection.immutable.Map[java.lang.String,Int] = Map(2 -> 2)

scala> map filterKeys (Set("1", "2") or Set("2", "3"))
res3: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3)

scala> map filterKeys !Set("2", "3")
res4: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1)

Cela peut être étendu à xor, nand etc etc et si vous incluez symbolique unicode peut faire pour étonnamment lisible le code:

val mustReport = trades filter (uncoveredShort ∨ exceedsDollarMax)

val european = { 
  val Europe = (_ : Market).exchange.country.region == Region.EU
  trades filter (_.market ∈: Europe)
}

Votre exemple avec les métiers de filtrage est assez cool. J'aime les ∈ méthode, lit juste comme les mathématiques.
Nice implicite pour le levage des opérations booléennes pour les prédicats. Je vais être d'emprunt qui.
Mieux me faire un Unicode clavier 🙂
Attention: filterKeys résultat encapsule la carte originale, sans copier les éléments. Cela peut être un problème pour les grandes structures, où vous attendent les éléments supprimés pour être nettoyée plus tard.

InformationsquelleAutor oxbow_lakes

9

Un tangentielle pointe, dans le cas où vous allez suivre le PredicateW idée de @oxbow_lakes' réponse:

En programmation fonctionnelle, au lieu de définir les fonctions ad hoc, nous visons le plus généralisée et composable abstractions. Pour ce cas particulier, Applicative correspond à la facture.

Set eux-mêmes sont des fonctions, et la Applicative exemple pour [B]Function1[A, B] nous permet de soulever des fonctions de cadre. En d'autres termes, vous pouvez soulever des fonctions de type (Boolean, Boolean) => Boolean (comme ||, && etc.) pour (A => Boolean, A => Boolean) => (A => Boolean). (Ici vous pouvez trouver une grande explication sur cette notion de levage.)

Cependant la structure de données Set lui-même a une Applicative instance disponible, qui sera favorisée par rapport à [B]Applicative[A => B] instance. Pour éviter cela, nous devrons indiquer explicitement au compilateur de traiter l'ensemble comme une fonction. Nous définissons un enrichissement pour que:
```
scala> implicit def setAsFunction[A](set: Set[A]) = new {
     |   def f: A => Boolean = set
     | }
setAsFunction: [A](set: Set[A])java.lang.Object{def f: A => Boolean}

scala> Set(3, 4, 2).f
res144: Int => Boolean = Set(3, 4, 2)
```
Et maintenant, mettez cette Applicative de bonté dans l'utilisation.
```
scala> val map = Map("1" -> 1, "2" -> 2, "3" -> 3)
map: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3)

scala> map filterKeys ((Set("1", "2").f |@| Set("2", "3").f)(_ && _))
res150: scala.collection.immutable.Map[java.lang.String,Int] = Map(2 -> 2)

scala> map filterKeys ((Set("1", "2").f |@| Set("2", "3").f)(_ || _))
res151: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3)

scala> map filterKeys (Set("2", "3").f map (!_))
res152: scala.collection.immutable.Map[java.lang.String,Int] = Map(1 -> 1)
```
Remarque: Tous les ci-dessus nécessite Scalaz.

InformationsquelleAutor missingfaktor
8

Désolé, pas une réponse directe à votre question, mais si vous savez que les touches sur lesquelles vous souhaitez supprimer (à la place de ceux que vous souhaitez conserver), vous pourriez faire ceci:
```
map -- Set("3")
```
- map -- (map.keySet &~ Set("1","2")) vous pouvez toujours calculer les clés à supprimer, étant donné que vous connaissez des touches à garder. (&~ est "différence", qui, je l'espère optimisé sur --)
- Pas très bon dans un tel environnement?
- Soin d'expliquer pourquoi ?
- Sudheer Reddy Aedama, aujourd'hui, 3 ans plus tard, je ne vois aucune raison pourquoi. Je crois que je me suis trompé alors.
InformationsquelleAutor Jesper

Vous devez vous connecter pour publier un commentaire.