Clojure Q&A - Recent questions tagged agent

Why does `await` fire off an `agent`'s watch?

Sat, 25 Jan 2025 04:40:53 +0000

I'm having trouble understand how await works on agents.
From the doc string reads

Blocks the current thread (indefinitely!) until all actions dispatched
thus far, from this thread or agent, to the agent(s) have occurred.

So sounds like it should wait for any tasks running on a given agent or any work that agent has dispatched itself (say to other agents or threads). So if I send something then I can await for it to finish.

However, it seems like a watch will also triggers for some reason...

(def bond (agent nil))

(add-watch bond
           :test
           (fn [_,_,_,_]
             (println "pew pew")))

(await bond)

;; the value of bond hasnt changed but it prints "pew pew" ..?

;; can be called an arbitrary number of times - keeps firing

(await bond)
(await bond)
(await bond)
(await bond)

add-watch docs read

Whenever the reference's state might have been changed, any registered watches will have their functions called.

However here the agent's state hasn't changed and yet it's fired

What's going on?

Is there a polished version of auto-agents?

Thu, 26 Dec 2024 18:41:21 +0000

I was reading Clojure in Action and thinking about agents. It seems that by hooking up agents with watches, update functions, and some simple locks, you could create a “reactive" state management. So that when some value a is updated then all dependent state values update themselves automatically and in parallel on separate threads. While those values are updating you are free to change other state values that aren't in the same dependency graph

I wrote up a quick draft but then started to look around online (it felt like a bit too obvious of an extension to the agent model). I found some similar ideas back in ~2009 but the trail goes dry. Is there some reason this isn't used more widely? Or is this some modern library I'm missing?

There was a "cell" implementation by Stuart Sierra called auto-agents - though I can't find the code

https://groups.google.com/g/clojure/c/NY834N34QvA

I also found this complete implementation but it's also got no traction at all

https://github.com/apatil/lazy-agent

Has this crystallized into a library somewhere? I'm thinking of writing my own implementation but I wanted a sanity check. I'm concerned maybe this idea was dropped for some reasons I've not considered

(I'm aware there are things like Javelin, Odoyle and Missionary that can accomplish similar things.. but while they decouple code, they're way too complicated and some don't have a threading story)

This is a copy of my question on Reddit:
https://reddit.com/comments/1hklfyh/comment/m3gyyoq

How can I retrieve all older values of a PDS like atom/ref/agents ?

Sun, 27 Feb 2022 11:04:39 +0000

Based on my impression a PDS like clojure atom/refs/agents stores all new values in a tree like data-structure as they get changed over-time.

Now, my questions are

In clojure, current values of an identity are could be accesses by defer/@ syntax, is it possible to access all the older values of an atom/ref/agent and print them ? If so, how ?
If older values of an identity are NOT accessible, then what happens to them ? They are still in memory right ? If I cannot access them, what is the point of having a tree like structure ?

How to known all the actions of an agent have been executed?

Tue, 05 Jan 2021 03:33:56 +0000

(def a (agent 0))

(dotimes [_ 100]
(send-off a inc))

How to determine the 100 actions have all been finished?