• (apply f args)
  • (apply f x args)
  • (apply f x y args)
  • (apply f x y z args)
  • (apply f a b c d & args)
Applies fn f to the argument list formed by prepending intervening arguments to args.

6 Examples top

  • user=> (def *strings* ["str1" "str2" "str3"])
    ;; Oops!
    user=> (str *strings*)
    "[\"str1\" \"str2\" \"str3\"]"
    ;; Yay!
    user=> (apply str *strings*)
    ;; Note the equivalence of the following two forms
    user=> (apply str ["str1" "str2" "str3"])
    user=> (str "str1" "str2" "str3")
  • ;; If you were to try
    user=> (max [1 2 3])
    [1 2 3]
    ;; You would get '[1 2 3]' for the result. In this case, 'max' has received one
    ;; vector argument, and the largest of its arguments is that single vector.
    ;; If you would like to find the largest item **within** the vector, you would need
    ;; to use `apply`
    user=> (apply max [1 2 3])
    ;; which is the same as (max 1 2 3)
  • ;; Here's an example that uses the optional second argument, args:
    user=> (apply map vector [[:a :b] [:c :d]])
    ([:a :c] [:b :d])
    ;; In this example, 'f' = 'map', 'args' = 'vector', and argseq = '[:a :b] [:c :d]',
    ;; making the above code equivalent to
    user=> (map vector [:a :b] [:c :d])
    ([:a :c] [:b :d]) ;Same answer as above
    ;; It might help to think of 'map' and 'vector' "slipping inside" the argument list
    ;; ( '[[:a :b] [:c :d]]' ) to give '[map vector [:a :b] [:c :d]]' , which then 
    ;; becomes the executable form '(map vector [:a :b] [:c :d])' .
  • ;; only functions can be used with apply.  'and' is a macro
    ;; because it needs to evaluate its arguments lazily and so
    ;; does not work with apply.
    user=> (apply and (list true true false true)
    -> ERROR
  • ;apply is used to apply an operator to its operands. 
    (apply + '(1 2))  ; equal to (+ 1 2)
    => 3
    ;you can also put operands before the list of operands and they'll be consumed in the list of operands
    (apply + 1 2 '(3 4))  ; equal to (apply + '(1 2 3 4))
    => 10
  • ;; You can use map and apply together to drill one level deep in a collection
    ;; of collections, in this case returning a collection of the max of each
    ;; nested collection
    user=> (map #(apply max %) [[1 2 3][4 5 6][7 8 9]])
    (3 6 9)
Log in to add / edit an example.

See Also top

Log in to add a see also.

Plus_12x12 Minus_12x12 Source clojure/core.clj:595 top

(defn apply
  "Applies fn f to the argument list formed by prepending intervening arguments to args."
  {:added "1.0"
   :static true}
  ([^clojure.lang.IFn f args]
     (. f (applyTo (seq args))))
  ([^clojure.lang.IFn f x args]
     (. f (applyTo (list* x args))))
  ([^clojure.lang.IFn f x y args]
     (. f (applyTo (list* x y args))))
  ([^clojure.lang.IFn f x y z args]
     (. f (applyTo (list* x y z args))))
  ([^clojure.lang.IFn f a b c d & args]
     (. f (applyTo (cons a (cons b (cons c (cons d (spread args)))))))))
Vars in clojure.core/apply:
Used in 0 other vars

Comments top

No comments for apply. Log in to add a comment.