在 Clojure 中将函数映射到映射的值

Question

我想将一个值映射转换为具有相同键但对值应用了函数的另一个映射。我认为 clojure api 中有一个函数可以做到这一点，但我一直找不到它。

这是我正在寻找的示例实现

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

有人知道 map-function-on-map-vals 是否已经存在？我认为确实如此（可能还有一个更好听的名字）。

Answer 1

我很喜欢你的 reduce 版本。我认为这是惯用的。无论如何，这是一个使用列表理解的版本。

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

Answer 2

您可以使用 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}

Answer 3

这是一种相当典型的转换地图的方法。
zipmap 接受一个键列表和一个值列表，并“做正确的事情”，生成一个新的 Clojure 映射。您还可以将 map 放在按键周围来更改它们，或两者都更改。

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

或者将其包装在您的函数中：

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

Answer 4

摘自《Clojure Cookbook》，有reduce-kv：

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

Answer 5

Clojure 1.11 在标准库 clojure.core 中添加了一个函数。 Clojure 1.11 于 2022 年 3 月 22 日发布。

update-vals< /a>

(update-vals mf) 将函数应用于映射中的每个值。它返回一个新的映射{k (fv) ...}。

用法

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

---

另请参阅： update-keys

(update-keys mf) 将函数应用于映射中的每个键。它返回一个新地图{(fk) v ...}。 (fk) 产生的所有键必须是唯一的。

Clojure 1.11 中也添加了此功能。

用法

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

Answer 6

这是一种相当惯用的方法：

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

示例：

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

Answer 7

map-map、map-map-keys 和 map-map-values

我知道 Clojure 中没有现有的函数，但这里有该函数的实现为您可以自由复制的map-map-values。它带有两个密切相关的函数，map-map 和 map-map-keys，标准库中也缺少这些函数：

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

用法

您可以调用 map- map-values 像这样：

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

另外两个函数像这样：

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

替代实现

如果您只想要 map-map-keys 或 map-map-values，如果没有更通用的 map-map 函数，您可以使用这些实现，它们不依赖于 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)} )))

此外，这里还有一个 map 的替代实现-map 基于 clojure.walk/walk< /a> 而不是 into（如果您更喜欢这种措辞） ：

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

并行版本 - pmap-map 等。

如果您需要，这些函数也有并行版本。他们只是使用 pmap 而不是 地图。

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

Answer 8

我是 Clojure n00b，所以很可能有更优雅的解决方案。这是我的：

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

anon func 根据每个键及其 f'ed 值创建一个小 2-列表。 Mapcat 在地图键的序列上运行此函数，并将整个作品连接成一个大列表。 “apply hash-map”根据该序列创建一个新的映射。 (% m) 可能看起来有点奇怪，它是 Clojure 的惯用用法，用于将键应用于映射以查找关联的值。

最强烈推荐阅读：Clojure Cheat Sheet 。

Answer 9

我喜欢你的 reduce 版本。通过非常微小的变化，它还可以保留记录结构的类型：

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

{} 被 m 替换。进行此更改后，记录仍然是记录：

(defrecord Person [firstname lastname])

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

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

通过以 {} 开头，记录将失去其记录性，如果您需要记录功能（紧凑内存），则可能希望保留该记录性例如代表）。

Answer 10

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

Answer 11

我想知道为什么还没有人提到 specter 库。它的编写是为了使这种转换易于编码（更重要的是，编写的代码易于理解），同时仍然非常高效：

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

用纯 Clojure 编写这样的函数很简单，但代码变得更加棘手一旦您转向由不同数据结构组成的高度嵌套的代码。这就是幽灵的用武之地。

我建议观看这一集 解释了 spectre 背后的动机和细节。

Answer 12

Clojure 1.7（发布 2015 年 6 月 30 日）提供了一个优雅的解决方案与 update 一起使用：

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

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