Clojure: Function Chaining

In Clojure, there's a special syntax to chain functions. (called pipe in unix shell. [see Unix Pipe as Functional Language])

For example, (f2 (f1 x)) can be written as (-> x f1 f2).

-> is a macro for “pipe”. It transforms syntax, from a linear notation into nested notation. This is also known as “function chaining”. Clojure calls this “threading”.

• (-> x f1) is equivalent to (f1 x)
• (-> x f1 f2) is equivalent to (f2 (f1 x))
• (-> x f1 f2 f3) is equivalent to (f3 (f2 (f1 x)))

;; example of using ->

(defn f1 "append \"1\" to a string" [x] (str x "1"))

(defn f2 "append \"2\" to a string" [x] (str x "2"))

(f1 "a") ; "a1"

(f2 "a") ; "a2"

;; pipe arg to function
(-> "x" f1) ; "x1"

;; pipe. function chaining
(-> "x" f1 f2) ; "x12"

• ->> is similar to ->, but pass arg into the last argument position of function.

Pass Binding

(as-> expr name form1 form2 form3 …) evaluate each form in turn, such that in form1 the name has value of expr, and in form2 the name has the value of form1's result, etc. Returns the result of the last form.

(as-> 4 x (list 3 x)) ; returns (3 4)

(as-> "a" x
      (list 1 x)
      (list 2 x)
      (list 3 x)
      (list 4 x)
      (list 5 x))

;; returns
;; (5 (4 (3 (2 (1 "a")))))