In the early core.async presentation, Rich argues that we should avoid putting application logic in callback handlers, and instead build the "machine like" parts of our code in the core.async model. To bridge from callback world to core.async we have put! and take! which we should call as soon as possible.
But what do we do if the library we are interfacing with relies on some effect having happened *before* the callback returns, but our application architecture dictates that effect should come from some other process? (go) (put!) and (take!) all return immediately. According to my (hopefully incorrect!) understanding, it's not possible. It seems to me we need something like (<!!), which is not available in cljs due to the lack of real threads. However, could we not have an implementation of (<!!) that goes something like this?: (defn <!! [c] (loop (or (poll! c) (if (any-process-ready?) (do (schedule-next-process!) (recur)) (throw "deadlock!"))))) This is making some uninformed assumptions about the scheduler, but presumably there must be: - Some kind of list of ready (not blocked on channel operations) processes - The ability to run a ready process until the next scheduling point (or until it runs out of processes). However I believe the scheduler is to be considered private/opaque, so a proper "userland" implementation would not be possible. -- Note that posts from new members are moderated - please be patient with your first post. --- You received this message because you are subscribed to the Google Groups "ClojureScript" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojurescript+unsubscr...@googlegroups.com. To post to this group, send email to clojurescript@googlegroups.com. Visit this group at https://groups.google.com/group/clojurescript.