Mapping einer Funktion auf die Werte einer Karte in Clojure

Ich verändern wollen, eine Karte von Werten zu einer anderen Karte mit dem gleichen Schlüssel, sondern mit einer Funktion, angewendet auf die Werte. Ich würde denken, es war eine Funktion, dies zu tun in der clojure-api, aber ich habe nicht in der Lage war, es zu finden.

Hier ist ein Beispiel für die Umsetzung dessen, was ich bin auf der Suche nach

(defn map-function-on-map-vals [m f]
  (reduce (fn [altered-map [k v]] (assoc altered-map k (f v))) {} m))
(println (map-function-on-map-vals {:a "test" :b "testing"} #(.toUpperCase %)))
{:b TESTING, :a TEST}

Weiß jemand, ob map-function-on-map-vals bereits vorhanden ist? Ich denke, es hat (wahrscheinlich mit einem schöneren Namen zu).

InformationsquelleAutor der Frage Thomas | 2009-11-04

  1. 133

    Ich mag deine reduce version ganz gut. Ich denke, es ist idiomatisch. Hier eine version mit list comprehension sowieso.

    (defn foo [m f]
  (into {} (for [[k v] m] [k (f v)])))

    InformationsquelleAutor der Antwort Brian Carper

  2. 85

    Können Sie die clojure.algo.generisches.Funktor/fmap:

    user=> (use '[clojure.algo.generic.functor :only (fmap)])
nil
user=> (fmap inc {:a 1 :b 3 :c 5})
{:a 2, :b 4, :c 6}

    InformationsquelleAutor der Antwort Arthur Edelstein

  3. 32

    Hier ist eine ziemlich typische Art und Weise zu transformieren, eine Karte.
    zipmap nimmt eine Liste von Schlüssel und eine Liste von Werten und "das richtige tut" Herstellung eines neuen Clojure-map. Man könnte auch die map um den Schlüssel zu ändern, oder beides. 

    (zipmap (keys data) (map #(do-stuff %) (vals data)))

    oder wickeln Sie es in Ihrer Funktion:

    (defn map-function-on-map-vals [m f]
    (zipmap (keys m) (map f (vals m))))

    InformationsquelleAutor der Antwort Arthur Ulfeldt

  4. 16

    Stammt aus der Clojure Cookbook, es zu reduzieren-kv:

    (defn map-kv [m f]
  (reduce-kv #(assoc %1 %2 (f %3)) {} m))

    InformationsquelleAutor der Antwort roboli

  5. 7

    Hier ist eine ziemlich idiomatischer Weg um dies zu tun:

    (defn map-function-on-map-vals [m f]
        (apply merge
               (map (fn [[k v]] {k (f v)})
                    m)))

    Beispiel:

    user> (map-function-on-map-vals {1 1, 2 2, 3 3} inc))
{3 4, 2 3, 1 2}

    InformationsquelleAutor der Antwort Siddhartha Reddy

  6. 3

    map-map, map-map-keys, und map-map-values

    Ich kenne keine bestehende Funktion in Clojure für diese, aber hier ist eine Implementierung der Funktion als map-map-values dass Sie sind frei zu kopieren. Es kommt mit zwei eng miteinander Verwandte Funktionen, die map-map und map-map-keys, die auch fehlen in der standard-Bibliothek:

    (defn map-map
    "Returns a new map with each key-value pair in `m` transformed by `f`. `f` takes the arguments `[key value]` and should return a value castable to a map entry, such as `{transformed-key transformed-value}`."
    [f m]
    (into (empty m) (map #(apply f %) m)) )

(defn map-map-keys [f m]
    (map-map (fn [key value] {(f key) value}) m) )

(defn map-map-values [f m]
    (map-map (fn [key value] {key (f value)}) m) )

    Nutzung

    Können Sie anrufen map-map-values wie diese:

    (map-map-values str {:a 1 :b 2})
;;           => {:a "1", :b "2"}

    Und die beiden anderen Funktionen wie diese:

    (map-map-keys str {:a 1 :b 2})
;;         => {":a" 1, ":b" 2}
(map-map (fn [k v] {v k}) {:a 1 :b 2})
;;    => {1 :a, 2 :b}

    Alternative Implementierungen

    Wenn Sie nur wollen map-map-keys oder map-map-values, ohne die Allgemeine map-map Funktion, die Sie verwenden können, diese Implementierungen, die verlassen sich nicht auf map-map:

    (defn map-map-keys [f m]
    (into (empty m)
        (for [[key value] m]
            {(f key) value} )))

(defn map-map-values [f m]
    (into (empty m)
        (for [[key value] m]
            {key (f value)} )))

    Auch hier ist eine alternative Implementierung von map-map basiert auf clojure.Spaziergang/walk statt in, wenn Sie dies bevorzugen Phrasierung:

    (defn map-map [f m]
    (clojure.walk/walk #(apply f %) identity m) )

    Parellel-Versionen – pmap-map usw.

    Gibt es auch parallele Versionen dieser Funktionen, wenn Sie Sie benötigen. So nutzen Sie einfach pmap statt map.

    (defn pmap-map [f m]
    (into (empty m) (pmap #(apply f %) m)) )
(defn pmap-map-keys [f m]
    (pmap-map (fn [key value] {(f key) value}) m) )
(defn pmap-map-values [f m]
    (pmap-map (fn [key value] {key (f value)}) m) )

    InformationsquelleAutor der Antwort Rory O'Kane

  7. 2

    Ich bin ein Clojure n00b, also kann es auch viel elegantere Lösungen. Hier ist meins:

    (def example {:a 1 :b 2 :c 3 :d 4})
(def func #(* % %))

(prn example)

(defn remap [m f]
  (apply hash-map (mapcat #(list % (f (% m))) (keys m))))

(prn (remap example func))

    Den anon func ist eine kleine 2-Liste von jeder Taste und seine f ' ed Wert. Mapcat läuft diese Funktion über die Abfolge der anzeigen die Tasten und wird das ganze Werk in eine große Liste. "gelten die hash-map" erzeugt eine neue Karte aus dieser Reihe. Die ("%m") kann schauen ein wenig seltsam, es ist Clojure idiomatisch für die Anwendung eine Taste, um eine Karte zu suchen, der entsprechende Wert.

    Meisten sehr zum Lesen empfohlen: Die Clojure Cheat Sheet .

    InformationsquelleAutor der Antwort Carl Smotricz

  8. 1

    Ich mag deine reduce version. Mit eine sehr leichte Variante, es kann auch weiterhin die Art von Aufzeichnungen Strukturen:

    (defn map-function-on-map-vals [m f]
  (reduce (fn [altered-map [k v]] (assoc altered-map k (f v))) m m))

    Den {} wurde ersetzt durch m. Mit dieser änderung von Datensätzen Datensätze bleiben:

    (defrecord Person [firstname lastname])

(def p (map->Person {}))
(class p) '=> Person

(class (map-function-on-map-vals p
  (fn [v] (str v)))) '=> Person

    Durch, beginnend mit {}, den Rekord verliert seine recordiness, die man vielleicht behalten wollen, wenn Sie wünschen, die record-Funktionen (compact-memory-Repräsentation für Beispiel).

    InformationsquelleAutor der Antwort Olivier

Schreibe einen Kommentar