Tôi muốn chuyển đổi một bản đồ các giá trị sang một bản đồ khác có cùng khóa nhưng với một hàm được áp dụng cho các giá trị. Tôi sẽ nghĩ rằng có một chức năng để làm điều này trong api clojure, nhưng tôi đã không thể tìm thấy nó.

Đây là một ví dụ thực hiện những gì tôi đang tìm kiếm

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

Có ai biết nếu map-function-on-map-valsđã tồn tại? Tôi sẽ nghĩ rằng nó đã làm (có lẽ với một cái tên đẹp hơn).

Tôi thích reducephiên bản của bạn tốt. Tôi nghĩ đó là thành ngữ. Đây là một phiên bản sử dụng danh sách hiểu mọi cách.

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

Bạn có thể sử dụng 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}

Đây là một cách khá điển hình để biến đổi bản đồ. zipmap lấy một danh sách các khóa và một danh sách các giá trị và "thực hiện đúng" tạo ra một bản đồ Clojure mới. Bạn cũng có thể đặt các mapphím xung quanh để thay đổi chúng hoặc cả hai.

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

hoặc để gói nó trong chức năng của bạn:

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

Lấy từ Clojure Cookbook, có giảm-kv:

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

Đây là một cách khá thành ngữ để làm điều này:

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

Thí dụ:

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

map-map, map-map-keysVàmap-map-values

Tôi biết không có chức năng hiện có trong Clojure cho việc này, nhưng đây là một triển khai của chức năng map-map-valuesđó vì bạn có thể tự do sao chép. Nó đi kèm với hai chức năng liên quan chặt chẽ map-mapvà map-map-keys, cũng bị thiếu trong thư viện tiêu chuẩn:

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

Sử dụng

Bạn có thể gọi map-map-valuesnhư thế này:

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

Và hai chức năng khác như thế này:

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

Triển khai thay thế

Nếu bạn chỉ muốn map-map-keyshoặc map-map-values, không có map-mapchức năng tổng quát hơn , bạn có thể sử dụng các triển khai này, không dựa vào 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)} )))

Ngoài ra, đây là một triển khai thay thế map-mapdựa trên clojure.walk/walkthay vì into, nếu bạn thích cụm từ này:

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

Phiên bản Parellel - pmap-map, v.v.

Ngoài ra còn có các phiên bản song song của các chức năng này nếu bạn cần chúng. Họ chỉ đơn giản là sử dụng pmapthay vì 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) )

Tôi là một Clojure n00b, vì vậy có thể có nhiều giải pháp thanh lịch hơn nhiều. Đây là của tôi:

(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 tạo một danh sách nhỏ 2 từ mỗi khóa và giá trị f'ed của nó. Mapcat chạy chức năng này qua chuỗi các phím của bản đồ và ghép toàn bộ các tác phẩm thành một danh sách lớn. "Áp dụng bản đồ băm" tạo ra một bản đồ mới từ chuỗi đó. (% M) có thể trông hơi kỳ lạ, đó là Clojure thành ngữ khi áp dụng khóa cho bản đồ để tra cứu giá trị liên quan.

Rất nên đọc: 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)))

tôi thích của bạn reduce phiên bản . Với một biến thể rất nhỏ, nó cũng có thể giữ lại kiểu cấu trúc bản ghi:

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

Các {} được thay thế bởi m. Với sự thay đổi đó, hồ sơ vẫn là hồ sơ:

(defrecord Person [firstname lastname])

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

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

Khi bắt đầu {}, bản ghi sẽ mất tính ghi , mà người ta có thể muốn giữ lại, nếu bạn muốn các khả năng ghi (ví dụ như biểu diễn bộ nhớ nhỏ gọn).

Tôi đang tự hỏi tại sao không ai nhắc đến thư viện bóng ma . Nó đã được viết để làm cho loại biến đổi này dễ viết mã (và, thậm chí quan trọng hơn, mã viết dễ hiểu), trong khi vẫn rất hiệu quả:

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

Viết một hàm như vậy trong Clojure thuần túy rất đơn giản, nhưng mã trở nên phức tạp hơn nhiều khi bạn chuyển sang mã được lồng cao bao gồm các cấu trúc dữ liệu khác nhau. Và đây là nơi bóng ma xuất hiện.

Tôi khuyên bạn nên xem tập này trên Clojure TV để giải thích động lực đằng sau và chi tiết về bóng ma .

Clojure 1.7 ( phát hành ngày 30 tháng 6 năm 2015) cung cấp một giải pháp thanh lịch cho việc này với 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"])