Add missing <! in list case of awalk

[ojw]

Looks like the list? case in awalk is missing an outer <!.

Alternately, there's a case to do a bit more refactoring and pull the <! (and optionally even the <outer) out of the cond, which would also fix this.

For example, something like

(go
  (<! 
    (<outer
      (cond ...))))

I'm happy to write it up either way if you like, or of course you're welcome to close this and fix it in the style of your choosing.

[jtkDvlp]

hey @ojw,

I sry for the late response, I will take a look and reply soon.

Thanks for your work.

[jtkDvlp]

Approved and merged, thank you for your work.

[ojw]

For what it's worth, I later abandoned this approach to an async postwalk. The problem is that empty collections lead to nils put on channels, and that signals termination in core.async. So I rewrote this using promises instead to get an async postwalk, and that has worked fine for me. As far as I can tell, for cases where there might be empty collections, this approach using channels just doesn't work.

I'm now using something like:

(defn promise-walk
  "`clojure.walk/walk, but inner and outer return promises."
  [inner outer form]
  (cond
    (list? form)
    (-> (map inner form)
        js/Promise.all
        (.then #(apply list %))
        (.then outer))

    (map-entry? form)
    (let [kp (inner (key form))
          vp (inner (val form))]
      (-> (js/Promise.all [kp vp])
          (.then (fn [[k v]] (MapEntry. k v nil)))
          (.then outer)))

    (seq? form)
    (-> (map inner form)
        js/Promise.all
        (.then outer))

    (record? form)
    (-> (reduce (fn [rp x]
                  (let [ip (inner x)]
                    (-> (js/Promise.all [rp ip])
                        (.then (fn [[r i]]
                                 (conj r i))))))
                form form)
        (.then outer))

    (coll? form)
    (-> (map inner form)
        js/Promise.all
        (.then #(into (empty form) %))
        (.then outer))

    :else
    (outer form)))

For me, dealing with promises is convenient, but this could always be adapted by converting to/from promises/channels.