Custom threading macro
I'd make a few modest changes. 


Don't use the helpers: use even? and count instead.
Reorder the arguments to insert-at to comply with those of assoc. 
Make the even-ness condition in n-&gt; an assertion: don't try to deal
with invalid cases.


Thus

(defn insert-at [xs n x]
  (let [[f-half s-half] (split-at n xs)]
    (concat f-half (cons x s-half))))


(Note the use of cons)

For example, 

(insert-at [1 2 3 4 5] 3 :a)
;(1 2 3 :a 4 5)


And

(defmacro n-&gt; [val &amp; forms]
  (assert (even? (count forms)))
  (if (seq forms)
    (let [[n form &amp; rest-forms] forms
          threaded  (insert-at form (inc n) val)]
      `(n-&gt; ~threaded ~@rest-forms))
    val))


For example, 

(macroexpand '(n-&gt; 1, 1 (+ 2), 0 (+ 3)))
;(+ (+ 2 1) 3)


Note that the macro now works (as an identity) with one argument:

(macroexpand '(n-&gt; (whatever you like)))
;(whatever you like)




Another approach is to do the work of the macro inside a function:

(defn n-&gt;fn [val &amp; forms]
  (assert (even? (count forms)))
  (let [pairs (partition 2 forms)]
    (reduce
     (fn [acc [n form]]
       (insert-at form (inc n) acc))
     val
     pairs)))


For example, 

(apply n-&gt;fn '(1, 1 (+ 2), 0 (+ 3)))
;(+ (+ 2 1) 3)


Once this function gets hold of the forms as data, it can do what the macro did without implicit recursion. 

So we can define the macro in terms of the function: 

(defmacro n-&gt; [&amp; stuff]
  (apply n-&gt;fn stuff))


... with identical results.