Clojurians Log v2
core-async
if i use a buffered chan as a queue - is it somehow possible to detect that the chan has more items in the buffer, when processing a take? use-case is we're using a chan to linearise events in clojurescript in a browser, to ensure that state updates are strictly "single threaded". it'd be great to detect that there are multiple events queued, so that we can process them all before updating state, rather than updating state once per event. i ask because it may be that core.async isn't designed for this, and this isn't possible. hoping to benefit from some more knowledgeable / experienced folks 🙂
It seems like poll! should work for this.
or are you trying to determine if there are more items without actually consuming them from the channel?
basically, when processing the next take, i'd like to soak up all buffered items at that time and process them. it may be that what i want isn't actually possible because of the single-threaded nature of js, and what i actually need is timer tick to check for and process whatever's queued, and not use async at all!
thanks for the response 🙂
yea, I think something like the following should work
(go
(loop []
(let [;; wait for something
x (<! ch)
;; consume until there's nothing left
batch (loop [batch [x]]
(let [x (poll! ch)]
(if x
(recur (conj batch x))
batch)))]
(process batch))
(recur)))you can also add timeouts to allow for more batching
nice i'm going to experiment with that, thanks man
re-frame uses a timer it seems https://github.com/day8/re-frame/blob/master/src/re_frame/router.cljc
your example looks like it might work! i wonder though, would successive put! actually be processed before the current take, given the single thread? my guess is no. i'll test to find out, and let you know!
I would also not expect successive puts to arrive in the same batch. for that, I would probably add a short timeout window for grouping multiple values into the same batch
yeah
if the producer already naturally groups outputs, then you could also batch at that end.
yeah. i thought about that too, but it won't fly; producers are browser events - user clicks and keypresses, xhr callbacks, websocket message callbacks, address changes, etc. we're using core.async to soak and linearise this ad-hoc, unpredictable stream of inputs
https://github.com/bsless/more.async/blob/master/src/main/clojure/more/async.clj#L514
neat, gonna read, thanks Ben!
JVM Clj only, right, @ben.sless?
I think the implementation of batch! should work in cljs
cool will check it out