What are the second ... in your first example?

second ...'s are just more parentheses

I think you've removed too much detail in simplifying your example. There might be a typo in the second one?

@U01AKQSDJUX posted response in main thread

So passing anonymous fns to a threading macro has some different expansion effects than you were expecting, see https://stackoverflow.com/questions/62948630/clojure-functions-and-thread-macro that could give you some clues 🙂

Your example expands to:

(fn {:a 42} [s] (conj s {:b 99}))

Use one of these (the first one is the best):

(-> {:a 42} 
    (conj {:b 99}))

=> {:a 42, :b 99}

(-> {:a 42}
    ((fn [s] (conj s {:b 99}))))

=> {:a 42, :b 99}

(-> {:a 42}
    (#(conj % {:b 99})))

=> {:a 42, :b 99}

As a matter pf style I’d not use a threading macro at all for anything less than 3 levels of parens (i.e. 1 as in this case). So my answer would be:

(conj {:a 42} {:b 99})

or this:

(conj (first [{:a 42}]) {:b 99})

(-> [{:a 42}] first (conj {:b 99}))

Any thing more than one nested form I’d probably use a threading macro.

@U05390U2P There will be > 10 nested function calls. Right now all I want to do is use threading macro correctly

What I want to do is this:

(-> some-starting-val
    f1
    f2
    f3
    ...
    fn)

e.g.

(->> "string"
     str/upper-case
     (assoc {:a 42} :string)
     (conj [{:b 99}]))

(conj [{:b 99}] 
  (assoc {:a 42} :string (str/upper-case "string")))

If all those functions are named (as in defined with defn) and take one argument then your (-> some-map f1 f2 f3) form will work

@U014Z9N3UTS you can do what you show if you don’t use anonymous fn’s in the threading macro. So either define the fns f1, f2, etc. using defn’s OR in a let or letfn that encloses the threaded form:

(let [f1 (fn [x] ...)
      f2 (fn [x] ...)
      f3 (fn [x] ...)
      ...]
  (-> some-starting-val
    f1
    f2
    f3
    ...
    fn))

You can use macroexpand-1 to show what the macro will expand to

Something else to be aware of is if you really need to have the argument be in some place besides the first argument of a function call (which is the main target of using an anonymous function here), you can use as-> For example

(-> {:your :data}
    (some-func-in-arg-1 {:extra :data})
    (as-> a (some-func-in-arg-2 {:more :data} a))
    another-func)

(although that case could use ->> instead of as->)

true

The mistake I made is that I passed in functions without wrapping in parentheses. For example, I did this:

(-> x f1 f2 f3)

(-> x (f1) (f2) (f3))

You shouldn't need to wrap the fns in parens if they only take one argument so I'm a little puzzled. Unless you're defining the fns anonymously in line in the threading macro rather than defn or let. In which case wrapping them in parens would resolve it but it's not idiomatic.

That's what the discussion started with, anonymous functions defined inline being used in thread pipelines.