What is sort of the "standard" way to deal with concurrent data structures with mutable state in clojure? Examples work wonders. So lets take the standard bank account example:

(defprotocol AccountAPI
  (withdraw [this amt] "withdraw the given amount from the account")
  (deposit [this amt] "deposit the given amount into the account"))

(defrecord Account [name balance]
  AccountAPI
  (withdraw [this amt] (conj this {:balance (- (:balance this) amt)}))
  (deposit [this amt] (conj this {:balance (+ (:balance this) amt)})))

(def account (atom (->Account "foo" 100)))

(require '[clojure.core.async :as async])

(dotimes [_ 5]
  (async/thread
    (swap! account withdraw 2)
    (swap! account deposit 1)))

@account ;; => {:name "foo", :balance 95}

In case of side effects, use locking I would say

I used a combination of deftype,`locking` and set! for my use case. The result just doesn't look and feel very clojure like, but more like some awkward translated java hence the question.

sometimes a man's gotta do what a man's gotta do

you can use refs too, if you have multiple things of state that need to be in sync

like two accounts

but in that case you still need to separate state changes from the io to perform

maybe returning what to perform as a value

Isn't this what dosync is for (too)?

@clojurians-slack100 From the docstring of dosync: > The exprs may be run more than > once, but any effects on Refs will be atomic.

i read a paper once where they implemented a few different ways to coordinate side effects in a transaction within Clojure’s STM

https://projekter.aau.dk/projekter/files/213827517/p10DOC.pdf

the one that felt most natural to me was the “defer” method that basically only ran the side effect once it was sure the transaction would commit

i think you can actually do something basically like that using agents

Agents already do that: > Agents are integrated with the STM - any dispatches made in a transaction are held until it commits, and are discarded if it is retried or aborted. https://clojure.org/reference/agents

The ants simulation uses this functionality: https://github.com/juliangamble/clojure-ants-simulation/blob/master/src/ants.clj

I have a sequence of maps representing tabular data rows, and i want to assoc in each row the running sum of the value of another "column":

(def rows
  [{:price 10 :qty 6}
   {:price 11 :qty 7}
   {:price 15 :qty 20}
   {:price 14 :qty 7}
   {:price 13 :qty 8}
   {:price 11 :qty 2}])

(defn with-reductions-col [old-key new-key rf rows]
  (let [agg (drop 1 (reductions rf (rf) (map old-key rows)))]
    (map (fn [row v] (assoc row new-key v)) rows agg)))


(with-reductions-col :qty :total + rows)
;;=>

({:price 10, :qty 6, :total 6}
 {:price 11, :qty 7, :total 13}
 {:price 15, :qty 20, :total 33}
 {:price 14, :qty 7, :total 40}
 {:price 13, :qty 8, :total 48}
 {:price 11, :qty 2, :total 50})

i'm really just curious to learn more... is there documentation that would explain why i consistently get sets seq'd in the same order? for example:

user=> (seq #{1 2 3})
(1 3 2)
user=> (seq #{"1" "2" "3"})
("3" "1" "2")