Je veux transformer une carte de valeurs en une autre carte avec les mêmes clés mais avec une fonction appliquée aux valeurs. Je penserais qu'il y avait une fonction pour faire cela dans l'api clojure, mais je n'ai pas pu la trouver.

Voici un exemple d'implémentation de ce que je recherche

(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}

Est-ce que quelqu'un sait s'il map-function-on-map-valsexiste déjà? Je pense que c'est le cas (probablement avec un nom plus joli aussi).

J'aime bien ta reduceversion. Je pense que c'est idiomatique. Voici une version utilisant de toute façon la compréhension de liste.

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

Vous pouvez utiliser clojure.algo.generic.functor/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}

Voici une manière assez typique de transformer une carte. zipmap prend une liste de clés et une liste de valeurs et "fait ce qu'il faut" en produisant une nouvelle carte Clojure. Vous pouvez également placer les maptouches autour des touches pour les changer, ou les deux.

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

ou pour conclure dans votre fonction:

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

Tiré du livre de cuisine Clojure, il y a réduire-kv:

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

Voici une façon assez idiomatique de faire cela:

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

Exemple:

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

map-map, map-map-keysetmap-map-values

Je ne connais aucune fonction existante dans Clojure pour cela, mais voici une implémentation de cette fonction car map-map-valuesvous êtes libre de copier. Il est livré avec deux fonctions étroitement liées, map-mapet map-map-keys, qui sont également absentes de la bibliothèque standard:

(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) )

Usage

Vous pouvez appeler map-map-valuescomme ceci:

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

Et les deux autres fonctions comme celle-ci:

(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}

Implémentations alternatives

Si vous voulez seulement map-map-keysou map-map-values, sans la map-mapfonction plus générale , vous pouvez utiliser ces implémentations, qui ne reposent pas sur 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)} )))

En outre, voici une implémentation alternative de map-mapqui est basée sur clojure.walk/walkau lieu de into, si vous préférez cette formulation:

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

Versions parallèles - pmap-map, etc.

Il existe également des versions parallèles de ces fonctions si vous en avez besoin. Ils utilisent simplement à la pmapplace de 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) )

Je suis un Clojure n00b, il peut donc y avoir des solutions bien plus élégantes. Voici la mienne:

(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))

La fonction anon fait une petite liste de 2 à partir de chaque clé et de sa valeur f'ed. Mapcat exécute cette fonction sur la séquence des touches de la carte et concatène l'ensemble des travaux en une seule grande liste. "apply hash-map" crée une nouvelle carte à partir de cette séquence. Le (% m) peut sembler un peu bizarre, c'est Clojure idiomatique pour appliquer une clé à une carte pour rechercher la valeur associée.

Lecture la plus fortement recommandée: The Clojure Cheat Sheet .

(defn map-vals
  "Map f over every value of m.
   Returns a map with the same keys as m, where each of its values is now the result of applying f to them one by one.
   f is a function of one arg, which will be called which each value of m, and should return the new value.
   Faster then map-vals-transient on small maps (8 elements and under)"
  [f m]
  (reduce-kv (fn [m k v]
               (assoc m k (f v)))
             {} m))

(defn map-vals-transient
  "Map f over every value of m.
   Returns a map with the same keys as m, where each of its values is now the result of applying f to them one by one.
   f is a function of one arg, which will be called which each value of m, and should return the new value.
   Faster then map-vals on big maps (9 elements or more)"
  [f m]
  (persistent! (reduce-kv (fn [m k v]
                            (assoc! m k (f v)))
                          (transient {}) m)))

J'aime ta reduceversion. Avec une très légère variation, il peut également conserver le type de structures d'enregistrements:

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

Le a {}été remplacé par m. Avec ce changement, les enregistrements restent des enregistrements:

(defrecord Person [firstname lastname])

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

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

En commençant par {}, l'enregistrement perd son caractère d' enregistrement , que l'on peut souhaiter conserver, si vous désirez les capacités d'enregistrement (représentation de mémoire compacte par exemple).

Je me demande pourquoi personne n'a mentionné le spectre bibliothèque de . Il a été écrit pour rendre ce type de transformation facile à coder (et, plus important encore, le code écrit facile à comprendre), tout en étant toujours très performant:

(require '[com.rpl.specter :as specter])

(defn map-vals [m f]
  (specter/transform
   [specter/ALL specter/LAST]
   f m))

(map-vals {:a "test" :b "testing"}
          #(.toUpperCase %))

Écrire une telle fonction dans Clojure pur est simple, mais le code devient beaucoup plus délicat une fois que vous passez à un code hautement imbriqué composé de différentes structures de données. Et c'est là que spectre entre en jeu.

Je recommande de regarder cet épisode sur Clojure TV qui explique la motivation derrière et les détails du spectre .

Clojure 1.7 ( publié le 30 juin 2015) offre une solution élégante pour cela avec update:

(defn map-function-on-map-vals [m f]
    (map #(update % 1 f) m))

(map-function-on-map-vals {:a "test" :b "testing"} #(.toUpperCase %))
;; => ([:a "TEST"] [:b "TESTING"])