Comment filtrer une persistance de la carte en Clojure?

J'ai une persistance de la carte que je veux filtre. Quelque chose comme ceci:

(filter #(-> % val (= 1)) {:a 1 :b 1 :c 2})

Ci-dessus en tant que ([:a 1] [:b 1]) (un paresseux séquence de la carte d'entrées). Cependant, je veux être obtenir {:a 1 :b 1}.

Comment puis-je filtrer une carte, donc il reste une carte sans avoir à reconstruire à partir d'une séquence d'entrées de mappage?

InformationsquelleAutor Alex B | 2010-05-02
  1. 48

    Et un autre:

    (let [m {:a 1 :b 2 :c 1}]
  (select-keys m (for [[k v] m :when (= v 1)] k)))
    InformationsquelleAutor kotarak
  2. 20
    (into {} (filter #(-> % val (= 1)) {:a 1 :b 1 :c 2}))

    Bien sûr, ce ne reconstruire la carte à partir d'une séquence de la carte des entrées, mais il n'y a pas moyen de contourner cela. Si vous allez pour filtrer les entrées en valeur, vous allez avoir à passer par un par un pour voir les valeurs qui correspondent à vos prédicat et qui ne le sont pas.

    Mis à jour (voir les commentaires ci-dessous):

    Avec la nouvelle keep fonction, la source de laquelle vous pouvez voir ici (devrait fonctionner très bien en Clojure 1.1 si vous voulez backport), cela semble être une belle façon d'aller à ce sujet si vous n'utilisez pas nil comme l'un des principaux:

    (let [m {:a 1 :b 1 :c 2}]
  (apply dissoc m (keep #(-> % val (= 1) (if nil (key %))) m)))
; => {:a 1, :b 1}

    Aussi, si vous ne vous en fait voir un ralentissement lié à la reconstruction de votre carte, vous pouvez utiliser un transitoire de la carte lors de l'étape de reconstruction:

    (persistent! (loop [m (transient {})
                    to-go (seq [[:a 1] [:b 2]])]
               (if to-go
                 (recur (apply assoc! m (first to-go))
                        (next to-go))
                 m)))
; => {:a 1, :b 2}
    • Eh bien, théorie vous pourriez avoir filtré par la valeur, sans reconstruction, en retournant une carte avec dissoc ed-clés qui correspondent à la non-correspondance des valeurs. J'espérais qu'il y est un langage soutenu de façon à le faire.
    • Ok, je vois ce que tu veux dire. Je vais ajouter deux façons de le faire en une seconde, mais notez que vous n'êtes pas très probable de voir un grand gain dans la direction de la performance (sauf si vous avez vraiment une énorme carte et vous aurez seulement être dissocing un petit nombre de touches).
    • Hm, en fait c'est pas tellement "deux façons de faire" comme "une façon de le faire et, d'une manière moins se soucier de la reconstruction". Non pas que vous aurez très probablement besoin de s'inquiéter. 🙂
    • en utilise transitoire conj!, donc je ne suis pas sûr qu'il y a un point d'en faire la boucle se reproduire
    InformationsquelleAutor Michał Marczyk
  3. 3

    Par votre commentaire Michał Marczyk:

    (defn filter* [f map]
  (reduce (fn [m [k v :as x]]
            (if-not (f x)
              (dissoc m k)
              m))
          map map))

user> (filter* #(-> % val (= 1)) {:a 1 :b 1 :c 2})
{:a 1, :b 1}

    Je ne vois pas que vous allez gagner beaucoup de choses avec ce vs Michał de la version.

    InformationsquelleAutor Brian Carper
  4. 3

    Est nécessaire de parcourir toutes les entrées, mais peuvent tirer parti de Clojures persistante des cartes:

    (apply dissoc my-map (for [[k v] my-map :when (not= v 1)] k))
    InformationsquelleAutor Jürgen Hötzel
  5. 1

    Je me suis essayé sur macro basé sur kotarak de la version. Sa ma première macro de faire quelque chose d'utile, de sorte s'il vous plaît garder avec moi et commentaires bienvenus.

    (defmacro filter-map [bindings pred m]
  `(select-keys ~m
    (for [~bindings ~m
      :when ~pred]
      ~(first bindings)
    )
  )
)

    Exemple

    user=> (filter-map [key val] (even? (:attr val)) {:a {:attr 2} :b {:attr 3} :c {:attr 4}})
{:c {:attr 4}, :a {:attr 2}}
    InformationsquelleAutor Benjamin Peter