Question

我的大多数应用程序状态都存储在一个大型复杂地图中。出于这个问题的目的，我将使用一个简单的结构：

(def data
  {:a 1
   :b {:c {:d 3}}})

我有大量的函数都遵循相同的模式：

(defn update-map
  [my-map val]
  (let [a (:a my-map)
        d (-> my-map :b :c :d)]
    (assoc-in
      (assoc my-map :a (+ a val))
      [:b :c :d] (+ d val))))

我从地图中检索一个或多个值，执行一些计算，并使用更新的值创建新地图。这种方法存在两个问题：

我在不同的函数定义中有很多重复的let绑定
如果地图的架构发生变化，我会有很多代码要重构

我编写了一个宏来减少定义这些函数所需的样板代码。它的工作原理是查找预定义的getter和setter函数，并自动生成一个let块：

(def getters
  {'a #(:a %)
   'd #(-> % :b :c :d)})

(def setters
  {'a #(assoc % :a %2)
   'd #(assoc-in % [:b :c :d] %2)})

(defmacro def-map-fn
  [name [& args] [& fields] & code]
  (let [my-map 'my-map
        lookup #(reduce % [] fields)
        getter-funcs (lookup #(conj % %2 (list (getters %2) my-map)))
        setter-funcs (lookup #(conj % (symbol (str "update-" %2)) (setters %2)))]
    `(defn ~name [~my-map ~@args]
       (let [~@getter-funcs ~@setter-funcs]              
         ~@code))))

我现在可以更优雅地定义我的功能：

(def-map-fn update-map
  [val] ; normal function parameters
  [a d] ; fields from the map I will be using
  (update-d
    (update-a my-map (+ a val))
    (+ d val)))

展开后，它会生成一个函数定义，如下所示：

(defn update-map
  [my-map val]
  (let [a (#(:a %) my-map)
        d (#(-> % :b :c :d) my-map)
        update-a #(assoc % :a %2)
        update-d #(assoc-in % [:b :c :d] %2)]
    (update-d
      (update-a my-map (+ a val))
      (+ d val))))

关于我的宏的一个问题是程序员不能直观my-map函数参数可以在函数体中使用。

这是一个很好用的宏，还是我应该完全使用不同的方法（比如动态var绑定）？

Answer 1

你可以使用镜头;然后getter和setter成为可组合的函数。看看here或here。

在第一个链接后，您可以按如下方式设置镜头：

; We only need three fns that know the structure of a lens.
(defn lens [focus fmap] {:focus focus :fmap fmap})
(defn view [x {:keys [focus]}] (focus x))
(defn update [x {:keys [fmap]} f] (fmap f x))

; The identity lens.
(defn fapply [f x] (f x))
(def id (lens identity fapply))

; Setting can be easily defined in terms of update.
(defn put [x l value] (update x l (constantly value)))

(-> 3 (view id))
; 3
(-> 3 (update id inc))
; 4
(-> 3 (put id 7))
; 7

; in makes it easy to define lenses based on paths.
(defn in [path]
  (lens
    (fn [x] (get-in x path))
    (fn [f x] (update-in x path f))))

(-> {:value 3} (view (in [:value])))
; 3
(-> {:value 3} (update (in [:value]) inc))
; {:value 4}
(-> {:value 3} (put (in [:value]) 7))
; {:value 7}

你可以看到上面的镜头可以根据你正在使用的数据结构调整使用get / set方法（例如get-in / update-in）。镜头的真正力量似乎也是你所追求的是你可以组成它们。在同一个例子中，组合函数可以定义如下：

(defn combine [outer inner]
  (lens
    (fn [x] (-> x (view outer) (view inner)))
    (fn [f x] (update x outer #(update % inner f)))))

(defn => [& lenses] (reduce combine lenses))

=＆gt;功能现在可用于组合任意镜头，如：

(-> {:new {:value 3}} (view (=> (in [:new]) (in [:value]))))
; 3
(-> {:new {:value 3}} (update (=> (in [:new]) (in [:value])) inc))
; {:new {:value 4}}
(-> {:new {:value 3}} (put (=> (in [:new]) (in [:value])) 7))
; {:new {:value 7}}

（在[：new]中）只是一个函数的事实意味着你可以，例如，存储它并以各种方式操纵它。例如，可以遍历嵌套的地图结构并创建镜头功能，这些功能对应于访问嵌套地图中每个级别的值，然后最后将这些功能组合在一起以创建getter / setter api。通过这种设置，您的镜头可以自动适应您架构中的任何变化。

组合镜头的能力还可以轻松与嵌套地图的节点进行交互。例如，如果您要将节点从原子更改为列表，则只需添加一个新镜头即可使用它，如下所示：

(def each (lens seq map))

(-> {:values [3 4 5]} (view   (=> (in [:values]) each)))
; (3 4 5)
(-> {:values [3 4 5]} (update (=> (in [:values]) each) inc))
; {:values (4 5 6)}
(-> {:values [3 4 5]} (put    (=> (in [:values]) each) 7))
; {:values (7 7 7)}

我强烈建议您查看完整的gist以查看有关镜头可以做些什么的更多示例。

Answer 2

在这种情况下，我的偏好是避免使用宏。它们经常混淆代码，但更重要的是它们不可编组。这里的理想解决方案允许您在def-map-fn中定义的函数之外使用getter和setter函数。我会尽可能地坚持常规功能和数据。

首先，如果您的架构发生变化，您会担心必须重写一堆代码。很公平。为了解决这个问题，我将从地图模式的数据表示开始。有关Clojure的全功能模式库，请参阅Prismatic schema，但是现在我们应该做以下几点：

(def my-schema
  {:a :int
   :b {:c {:d :int}}})

由此，您可以计算架构中所有属性的路径：

(defn paths [m]
  (mapcat (fn [[k v]]
            (conj (if (map? v)
                    (map (partial apply vector k) (paths v)))
                  [k]))
          m))

(def property-paths
  (into {} (for [path (paths my-schema)] [(last path) path])))

现在，要获取或设置属性，您可以查看其路径并将其与get-in，update-in等一起使用，并酌情使用：

(let [d (get-in my-map (property-paths :d))]
  ;; Do something with d.
  )

如果你厌倦了总是打电话给get-in，assoc-in等，那么你可以很容易地生成一堆getter函数：

(doseq [[p path] property-paths]
  (eval `(defn ~(symbol (str "get-" (name p)))
           [m#] (get-in m# ~path))))

(doseq [[p path] property-paths]
  (eval `(defn ~(symbol (str "set-" (name p)))
           [m# v#] (assoc-in m# ~path v#))))

(doseq [[p path] property-paths]
  (eval `(defn ~(symbol (str "update-" (name p)))
           [m# tail#] (apply update-in m# ~path #tail))))

现在，您的代码中随处可见get-a，set-a，update-a个函数，而无需调用某个超级宏来为您设置绑定。例如：

(let [a (get-a my-map)]
  (-> my-map
      (set-a 42)
      (update-d + a)))

如果您确实发现设置上述let绑定繁琐，您甚至可以编写一个接受地图和属性名称列表的with-properties宏，并在绑定值的上下文中执行主体对于那些名字。但我可能不会打扰。

这种方法的优点包括：

它是模式驱动的，因此模式在一个中心位置定义，并用于根据需要生成其他代码。
它优先于宏的纯函数，因此代码更易于重用和可组合。
这是一种增量方法，可以让您的应用程序更自然地增长。不是从尝试预测所有可能的功能的超级宏开始，而是从数据和函数开始，然后在宏中使用，以减轻重复性，因为您会看到使用模式的出现。

Answer 3

为什么不使用update-in？

(defn update-map [my-map val]
  (-> my-map
      (update-in [:a] + val)
      (update-in [:b :c :d] + val)))

使用宏绑定getter和setter

3 个答案: