函数的哈希码在原子内部发生变化......为什么会发生这种情况？

Question

作为我正在研究的数据可视化应用程序的一部分,我遇到了一些奇怪的错误,或者我从根本上不理解某些东西.

我的应用程序具有代码,该代码采用表示颜色标量的数据结构并将它们转换为带有数字并返回颜色RGB值的散列的函数.

渐变和范围颜色标量都实现了:

{:type :gradient
 :scale [{:bound 0 :r 0 :g 0 :b 0}
         {:bound 1 :r 255 :g 0 :b 0}
         {:bound 2 :r 0 :g 255 :b 0}]}

{:type :range
 :scale [{:bound [[< 0]] :r 250 :g 250 :b 250}
         {:bound [[>= 0] [< 1]] :r 0 :g 0 :b 0}
         {:bound [[>= 1] [< 2]] :r 255 :g 0 :b 0}
         {:bound [[>= 2]] :r 0 :g 255 :b 0}}]

有些功能可以将这些功能转化为功能,其用法类似于以下内容:

((create-colorscale-fn **GRADIENT-MAP**) 1.5) => {:r 128 :g 128 :b 0}
((create-colorscale-fn **RANGE-MAP**) 1.5) => {:r 255 :g 0 :b 0}

还有一些函数可以在两者之间进行转换,但这一个是与我的帖子相关的函数:

(defn- gradient-colorscale-to-range
  [in]
  {:pre [(verify-gradient-colorscale in)]
   :post [(verify-range-colorscale %)]}
  {:type :range
   :scale (into []
        (concat
         (let [{:keys [bound]} (-> in :scale first)
               {:keys [r g b]} {:r 250 :g 250 :b 250}]
           [{:bound [[< bound]] :r r :g g :b b}])
         (mapv (fn [[a {:keys [r g b]}]] {:bound a :r r :g g :b b})
               (partition 2 (interleave
                     (map (partial apply vector)
                      (partition 2
                             (interleave
                              (map #(vector >= (:bound %)) (-> in :scale))
                              (map #(vector < (:bound %)) (-> in :scale rest)))))
                     (-> in :scale))))
         (let [{:keys [bound r g b]} (-> in :scale last)]
           [{:bound [[>= bound]] :r r :g g :b b}])))})

"verify-range-colorscale"函数的一部分测试了关于不等运算符的以下条件:

(every? #{< <= > >=} (map first (mapcat #(-> % :bound) (:scale in))))
 ;;Each bound must consist of either <= < >= >

这是我的问题所在:

出于某种原因,大多数情况下,当我运行此函数时,它不会给我任何问题,并且适当的不等式运算符的测试运行应该:

(def gradient
    {:type :gradient
    :scale [{:bound 0 :r 0 :g 0 :b 0}
             {:bound 1 :r 255 :g 0 :b 0}
             {:bound 2 :r 0 :g 255 :b 0}]})

 (#{< <= > >=} (get-in (gradient-colorscale-to-range gradient) [:scale 0:bound 0 0])) 
     => #object[clojure.core$_LT 0x550b46f1 "clojure.core$_LT_@550b46f1

但是,颜色标量设置在原子内部,其内容可以在全局变量中找到.我开发了一些编辑器,它们将色阶状态的一部分复制到另一个原子中,然后使用图形编辑器进行编辑.当我将渐变转换为原子内的范围时,将原子的内容关联到全局原子中,然后检查操作符的相等性,由于某些奇怪的原因,测试失败.

 (#{< <= > >=} (get-in (gradient-colorscale-to-range gradient) [:scale 0:bound 0 0])) 
     => nil

当我检查为什么它失败时,看起来小于函数的哈希码在原子更新期间的某个时刻发生了变化.

(mapv #(format "%x" (.hashCode %)) [< (get-in @xmrg-cache [[0 0] :colorscale :scale 0 :bound 0 0])])
   -> ["550b46f1" "74688dde"]

由于集合包含显然基于其哈希码测试函数,这导致我的"验证范围 - 颜色规模"测试失败.

所以问题是,为什么我的不等式函数的哈希码在原子更新期间会发生变化？它是clojure.core中定义的一个函数,但它似乎是在某个时候制作它的副本？

---

编辑以回应Piotrek:

数据结构存储在命名空间"inav"中的全局​​原子中.

加载<:的哈希码时:

 (format "%x" (.hashCode <)) => "425b1f8f"

使用转换函数从repl更改存储在显示配置原子中的色阶时:

 (swap! xmrg-cache update-in [[0 0] :colorscale gradient-colorscale-to-range)
 (format "%x" (.hashCode (get-in @xmrg-cache [[0 0] :colorscale :scale 0 :bound 0 0]))) => "425b1f8f"

有一个图形色阶编辑器,它使用一系列手表来编辑临时副本,然后再更新活动配置.通过单击色阶预览图像启动它:

  (.addMouseListener colorscale-img-lbl
     (proxy [MouseAdapter] []
        (mouseClicked [me]
           (let [cscale-atom (atom (get-in @xmrg-cache [(find-pane-xy e) :colorscale]))]
              (add-watch cscale-atom :aoeu
                 (fn [k v os ns]
                     (swap! xmrg-cache assoc-in [(find-pane-xy parent-e) :colorscale] ns)
                     (redrawing-function)))
              (launch-colorscale-editor cscale-atom other-irrelevant-args))))

然后launch-colorscale-editor有很多选项,但相关的部分是转换组合框和应用按钮:

(defn- launch-colorscale-editor [cscale-atom & other-irrelevant-args]
  (let [tmp-cscale-atom (atom @cscale-atom)
        convert-cb (doto (JComboBox. (to-array ["Gradient" "Range"]))
                      (.setSelectedItem ({:range "Range" :gradient "Gradient"} (:type @tmp-cscale-atom)))
        apply-button (JButton. "Apply")]
     (add-action-listener convert-cb
         (fn [] (let [prev-type (:type @tmp-cscale-atom)
                      new-type ({"Gradient" :gradient "Range" :range} (.getSelectedItem convert-cb))]
                   (when (not= prev-type new-type)
                     (case [prev-type new-type]
                           [:gradient :range] (swap! tmp-cscale-atom gradient-colorscale-to-range)
                           ;other options blah blah
                      )))))
     (add-action-listener apply-button
        (fn [] (reset! cscale-atom @tmp-cscale-atom)
               (redrawing-function))))

基本上,当你单击apply时,你将tmp-cscale-atom的内容(在''inav/create-colorscale-editor里面)复制到cscale-atom(在''inav/more中的let-block里面) -grid-options-dialog),它触发一个手表,自动将cscale-atom的色阶复制到xmrg-cache(全局定义的''inav/xmrg-cache).

当以这种方式编辑它时,<的哈希码最终成为了这个

(format "%x" (.hashCode (get-in @xmrg-cache [[0 0] :colorscale :scale 0 :bound 0 0]))) => "5c370bd0"

关于这种行为的最后一点说明:

当您从INSIDE应用按钮动作侦听器调用"重绘功能"时,尝试验证范围颜色等级是成功的.

当您从OUTSIDE应用按钮动作侦听器调用"重绘功能"后,尝试验证范围颜色等级失败.

...我刚刚发现问题,我正在重新评估色阶,作为我刷新色阶时调用的重新验证功能的一部分.这搞砸了.

Answer 1

Clojure 中的函数是实现接口的常规 Java 对象clojure.lang.IFn。当您加载命名空间（包括clojure.core）时，Clojure 将编译函数（生成一个新的 Java 类，创建它的实例，并将该实例分配为 var 值）。例如，#'clojure.core/<var 将获得一个新的 Java 对象，clojure.lang.IFn该对象实现恰好是小于逻辑。

Clojure 不会覆盖hashCode生成的函数类中的实现，因此它继承了java.lang.Object. 因此，每个新实例都有其自己的可能不同的哈希码。这导致了您的问题：当名称空间重新加载时，变量将获得新的函数实例，从而获得不同的哈希码。

另一方面，我会检查你的测试是如何工作的：

• 在测试执行期间是否重新加载了任何名称空间？
• 您是否在测试函数范围之外存储全局状态（例如<全局原子中的函数）？

也许您应该在测试函数中使用本地范围来获取预期值？