I have a list of functions that take callbacks, and I want to exec them in order. e.g.

[proc1 proc2 proc3 ,,, procN]

(proc1 (fn [] (proc2 (fn [] (proc3 ,,,)))))

is there a cheap way to construct this callback chain?

Will (apply comp (reverse procs)) work?

ohh, those inner fns complicate it

:thinking_face:

Recursive macro is probably the way to go.

yeah I’m just going to punt on it for now

Why the fns?

Why not just (proc1 (proc2 (proc3 ,,,)))?

Oh, wait, nvm.

I'd just go with a macro.

because proc<1,,N> are async

I’m writing a task-type similar to promises

so you write:

(def pipeline
 (->
  (task1)
  (t/join (task2))
  (t/join (task3))
  ,,,
  (t/join (taskN))))

(t/run! pipeline #(prn "done"))

right now, each t/join creates a new Task that calls run! when the previous task succeeds, building the callback chain on instantiation I was wondering if it would be better to store each task in a queue and wire up the callback chain on run!, but that seems harder

I wrote a basic macro that does what you want, I think. I'm not sure about the end-case.

(defmacro callbacks
  [proclist]
  (if (= (count proclist) 1)
    (first proclist)
    `(~(first proclist) (fn [] (callbacks ~(rest proclist))))))

(clojure.walk/macroexpand-all '(callbacks [:proc1 :proc2 :proc3 :proc4]))
;; => (:proc1 (fn* ([] (:proc2 (fn* ([] (:proc3 (fn* ([] :proc4)))))))))

There's probably a more efficient way using a loop, but that works.

Just curious lilactown (granted, I don't know if this is the most elegant) you are referring to something like this right

(defn run-callbacks [callbacks]
  (let [ run-callbacks-fn
        (->> callbacks
             reverse
             (reduce 
              (fn [inner-procs proc] 
                (fn [next] (proc (fn [] (inner-procs next)))))))]
    (run-callbacks-fn (fn [] ))))

(run-callbacks [(fn [callback] (println "One") (callback))
                (fn [callback] (println "Two") (callback))
                (fn [callback] (println "Three") (callback))])
;; user> 
;; One 
;; Two 
;; Three 

yep, that’s the gist of it!

that’s not too bad tbh. I think that creating the callback chain on instantiation will be more performant (no seqs involved), but using a list of callbacks might give more ability for runtime inspection

copying and pasting that to experiment with 😅