Clojure Core function argument positions seem rather confusing. What's the logic behind it?

Question

For me as, a new Clojurian, some core functions seem rather counter-intuitive and confusing when it comes to arguments order/position, here's an example:

> (nthrest (range 10) 5) 
=> (5 6 7 8 9)

> (take-last 5 (range 10)) 
=> (5 6 7 8 9)

Perhaps there is some rule/logic behind it that I don't see yet?

I refuse to believe that the Clojure core team made so many brilliant technical decisions and forgot about consistency in function naming/argument ordering.

Or should I just remember it as it is?

Thanks

---

Slightly offtopic:

rand&rand-int VS random-sample - another example where function naming seems inconsistent but that's a rather rarely used function so it's not a big deal.

Answer 1

For some functions (especially functions that are "seq in, seq out"), the args are ordered so that one can use partial as follows:

(ns tst.demo.core
  (:use tupelo.core tupelo.test))

(dotest
  (let [dozen      (range 12)
        odds-1     (filterv odd? dozen)
        filter-odd (partial filterv odd?)
        odds-2     (filter-odd dozen) ]
    (is= odds-1 odds-2
      [1 3 5 7 9 11])))

For other functions, Clojure often follows the ordering of "biggest-first", or "most-important-first" (usually these have the same result). Thus, we see examples like:

(get <map> <key>)
(get <map> <key> <default-val>)

This also shows that any optional values must, by definition, be last (in order to use "rest" args). This is common in most languages (e.g. Java).

---

For the record, I really dislike using partial functions, since they have user-defined names (at best) or are used inline (more common). Consider this code:

  (let [dozen   (range 12)
        odds    (filterv odd? dozen)

        evens-1 (mapv (partial + 1) odds)
        evens-2 (mapv #(+ 1 %) odds)
        add-1   (fn [arg] (+ 1 arg))
        evens-3 (mapv add-1 odds)]

    (is= evens-1 evens-2 evens-3
      [2 4 6 8 10 12]))

---

Also

I personally find it really annoying trying to parse out code using partial as with evens-1, especially for the case of user-defined functions, or even standard functions that are not as simple as +.

This is especially so if the partial is used with 2 or more args.

• For the 1-arg case, the function literal seen for evens-2 is much more readable to me.

• If 2 or more args are present, please make a named function (either local, as shown for evens-3), or a regular (defn some-fn ...) global function.

Answer 2

Functions that work with seqs usually has the actual seq as last argument. (map, filter, remote etc.)

Accessing and "changing" individual elements takes a collection as first element: conj, assoc, get, update

That way, you can use the (->>) macro with a collection consistenly, as well as create transducers consistently.

Only rarely one has to resort to (as->) to change argument order. And if you have to do so, it might be an opportunity to check if your own functions follow that convention.

Answer 3

There is an FAQ on Clojure.org for this question: https://clojure.org/guides/faq#arg_order

What are the rules of thumb for arg order in core functions?

Primary collection operands come first. That way one can write → and its ilk, and their position is independent of whether or not they have variable arity parameters. There is a tradition of this in OO languages and Common Lisp (slot-value, aref, elt).

One way to think about sequences is that they are read from the left, and fed from the right:

<- [1 2 3 4]

Most of the sequence functions consume and produce sequences. So one way to visualize that is as a chain:

map <- filter <- [1 2 3 4]

and one way to think about many of the seq functions is that they are parameterized in some way:

(map f) <- (filter pred) <- [1 2 3 4]

So, sequence functions take their source(s) last, and any other parameters before them, and partial allows for direct parameterization as above. There is a tradition of this in functional languages and Lisps.

Note that this is not the same as taking the primary operand last. Some sequence functions have more than one source (concat, interleave). When sequence functions are variadic, it is usually in their sources.

Adapted from comments by Rich Hickey.