Clojure，代理，缺乏副作用

Question

我使用代理来操纵结构，但我没有所有的副作用。

所有的信息都被发送（我已经打印并统计了它们），但有时候我没有全部的副作用。好像并非我的所有功能都应用于代理的状态，或者如果最后一次发送应用于以前的状态。

我尝试过使用doall，dorun但未找到解决方案，非常感谢任何帮助。

;; aux function for adding an element to a hashmap 
(defn extend-regs [reg s o] 
    (let [os (get reg s)] 
    (if (nil? os) 
     (assoc reg s [o]) 
     (assoc reg s (conj os o))))) 

;; the agent's altering function - adding an element to the :regs field(a hashmap) 
(defn add-reg! [d s o] 
    (send d (fn [a] (assoc a :regs (extend-regs (:regs a) s o))))) 



;; Creating the agents, dct/init returns an agent 
;; pds: data for fields 
(defn pdcts->init-dcts! [pds] 
    (doall (map dct/init (map :nam pds) (repeat nil)))) 

;; Altering one agent's state, dct/add-reg sends an assoc message to the agent 
;; d: agent, pd: data for fields 
(defn dct->add-regs! [d pd] 
    (dorun (map (fn [s r] (dct/add-reg! d s r)) 
      (:syms pd) 
      (:regs pd))) 
    d) 

;; Going through all agents 
;; ds: agents, pds: datas 
(defn dcts->add-regs! [ds pds] 
    (dorun (map (fn [d pd] (dct->add-regs! d pd)) 
      ds 
      pds)) 
    ds) 

编辑：========================================= ============

好吧，事实证明我只是没有足够等待我的线程完成他们的任务。现在的问题是如何监控我的代理。我怎么知道队列中有未完成的线程？我只找到swank.core/活动线程和类似的，但它们不是解决方案。

Answer 1

使用await或await-for等到代理完成它的当前工作队列：

(await agent1 agent2 agent3) 

或

(apply await list-of-agents) 

附加REG的轻微改善：

(defn extend-regs [reg s o] 
    (update-in reg [s] conj o)) 

这工作，因为

(conj nil :b)    ; => [:b] 

从而

(update-in {} [:a] conj :b) ; => {:a [:b]} 

最后我们。

(defn add-reg! [d s o] 
    (send d update-in s [:regs] conj o) 

Answer 2

我没有你的问题的解决方案，但我不能抗拒提出一些改进的前两个功能：

(defn extend-regs [reg s o] 
    (let [os (get reg s)] 
    (if (nil? os) 
     (assoc reg s [o]) 
     (assoc reg s (conj os o))))) 
;; => place the 'if inside the assoc: 
(defn extend-regs [reg s o] 
    (let [os (get reg s)] 
    (assoc reg s (if (nil? os) [o] (conj os o))))) 
;; => this (if (nil? x) ...) is the pattern of function fnil, so ... 
(defn extend-regs [reg s o] 
    (let [os (get reg s)] 
    (assoc reg s ((fnil conj []) os o)))) 
;; with update-in, this will be even clearer, and we can remove the let altogether: 
(defn extend-regs [reg s o] 
    (update-in reg [s] (fnil conj []) o)) 

至于第二：

(defn add-reg! [d s o] 
    (send d (fn [a] (assoc a :regs (extend-regs (:regs a) s o))))) 
;; => We can, again, use update-in instead of assoc: 
(defn add-reg! [d s o] 
    (send d (fn [a] (update-in a [:regs] extend-regs s o)))) 
;; or, if you can get rid of extend-regs: 
(defn add-reg! [d s o] 
    (send d (fn [a] (update-in a [:regs s] (fnil conj []) o))) 

最后，作为一个风格问题，我会将add-reg放在一个单独的函数中，并直接使用在客户端代码中发送给代理的方式（或者有一个简化的add-reg！函数）：

(defn add-reg [v s o] (update-in v [:regs s] (fnil conj []) o)) 

(defn add-reg! [d s o] (send d add-reg)) 

我知道这并不能回答你最初的问题，但很好玩写这一步一步的重构