about 2. you could further destructure in the let

(defn example [{:keys [attr sub dispatch]}]
 (let [{:keys [on-blur on-change]} dispatch]
  ...))

Actually this works

(defn example [{:keys [attr sub dispatch] 
                {:keys [on-blur on-change]} :dispatch}]
  (println attr sub dispatch on-blur on-change))

about 1. you can do this

(def dispatch { :on-blur 2})
(let [a 1 {on-change :on-change :or {on-change 3}} dispatch]
  (println a on-change))
=> 1 3

sorry the above is not what you asked, but I think you can use cond->>

(defn text-input [{:keys [attrs subscription] {on-change :on-change} :dispatch}]
  (let [local (r/atom (or @subscription ""))]
    (fn []
      [:input.input
        (merge attrs
          {:type :text
           :on-change #(cond-> %
                            true (other-fn -target -value)
                            true (reset! local)
                            on-change (on-change))
           :value @local})])))

ohhh I tried to do the second destructure example you showed but I think I was using 'dispatch' instead of ':dispatch' for the inner destructure, that makes sense though thanks for figuring it out!

And I was unaware of the cond-> threading so that's cool to see as well. Thanks so much Antonio!

Not executing the function is the best approach, but in case you encounter this again, all forms of get allow for a “not-found” value. So instead of: (or (:on-change dispatch) (fn [])) you can write: (:on-change dispatch (fn []))

The primary difference here is that the value you pass is not evaluated if you don’t need it and you use or. So you definitely wouldn’t use this form for: (:on-change dispatch (some-really-expensive-fn))

@U051N6TTC thanks for pointing out the optional defaults- I'm coming over from Java and can't get over (in a good way!) the number of convenience overloads that Clojure sneaks in haha. Do you happen to know what the use case is in not having default value producer short-circuited?

Most of the time when you’re doing a lookup (via get, keyword-as-fn, or map-as-fn) then returning nil works just fine, but if you do need a default value, then it’s typically a constant, e.g. :not-found. In that case, it’s perfectly fine to provide it as an argument. Using or to short circuit something away is just useful when there’s some kind of operation that’s going to happen that you want to avoid

You should get a compilation error mentioning the cyclic dependency

Ok thanks @U06BE1L6T

(defn update-maybe [m k f & args] (if (contains? m k) (update m k #(apply f % args)) m)) (a missing paren fixed)

Thanks very much, I’m using that update maybe function.

I see. But the problem I have is say for example a function g takes as parameter t and I want to implement a function f that takes as parameter g but not t

so something like

(defn f [g]
  (fn [t] (g t))

if I understand you correctly

(of course that simplifies to (def f g) but you could have other logic in there)

I worked! Thanks for the help. The answer was

(defn make-eta [nu t1 t2]
    (fn [t] (* (- t t1) (- t t2) (nu t))))

Oh I see. I think the key is higher order functions, haven't learned about those yet. I should look into those.

in clojure those just work, and functions are values that can be passed and returned no different from the number 5

but I dunno about sicmutils