clojure.core/partial

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 15 Runnable: 10

([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])

Takes a function f and fewer than the normal arguments to f, and returns a fn that takes a variable number of additional args. When called, the returned function calls f with args + additional args.

Examples

by nipra on 2010-07-13 . May have evaluation errors. ▶

(def to-english (partial clojure.pprint/cl-format nil "~@(~@[~R~]~^ ~A.~)")) #'user/to-english (to-english 1234567890) "One billion, two hundred thirty-four million, five hundred sixty-seven thousand, eight hundred ninety"

by nipra on 2010-07-13 . May have evaluation errors. ▶

(def hundred-times (partial * 100)) #'user/hundred-times (hundred-times 5) 500 (hundred-times 4 5 6) 12000 (def add-hundred (partial + 100)) #'user/add-hundred (add-hundred 5) 105

by philos99 on 2011-10-04 ▶

(def subtract-from-hundred (partial - 100)) (subtract-from-hundred 10) ; same as (- 100 10) 90 (subtract-from-hundred 10 20) ; same as (- 100 10 20) 70

by mihirmp on 2012-06-09 ▶

; Maps exponent to coefficient ; x^3 + 2x + 1 (def poly (fn [n] (cond (= 0 n) 1 (= 1 n) 2 (= 3 n) 1 :else 0))) ; Differentiates input by returning a polynomial that is curried ; 3x^2 + 2 (defn diff [p] (partial (fn [p n] (* (+ 1 n) (p (+ 1 n)))) p)) (poly 3) ;=> 1 ((diff poly) 3) ;=> 0 ((diff poly) 2) ;=> 3

by ftravers on 2015-08-28 ▶

(defn fun-full [x y] (+ x y)) ;=> #<function user$fun_full(x,y){ ... (fun-full 2 3) ;=> 5 (def fun-half (partial fun-full 2)) ;=> #<function (x,y,z,var_args){ ... (fun-half 3) ;=> 5

by liango2 on 2015-12-27 . May have evaluation errors. ▶

;;Takes a function f and the normal full arguments is allowed (defn add [x y] (+ x y)) #'user/add (partial add 1 1 ) #object[clojure.core$partial$fn__4529 0x5eb8fe04 "clojure.core$partial$fn__4529@5eb8fe04"] (apply (partial add 1 1 ) nil) 2 ((partial add 1 1 )) 2 ((partial add 1 1 1)) ArityException Wrong number of args (3) passed to: user/add clojure.lang.AFn.throwArity (AFn.java:429)

by gosukiwi on 2016-08-10 . May have evaluation errors. ▶

(def add1 (partial + 1)) #'user/add1 (add1) ;=> 1 (add1 2) ;=> 3 (add1 2 3 4) ;=> 10 (= (add1 2 3 4) (+ 1 2 3 4)) ;=> true

by Lacty on 2016-08-10 ▶

(def times (partial *)) (times 1) ; -> 1 (times 1 2 3) ; -> 6 (* 1 2 3) ; -> 6 (def add-hundred (partial + 100)) (add-hundred 1) ; -> 101 (add-hundred 1 2 3) ; -> 106 (+ 100 1 2 3) ; -> 106

by codxse on 2017-01-14 ▶

;; Check if a character is vowel (def vowel? #(some (partial = %) "aiueo")) (vowel? \e) ;;=> true (vowel? \c) ;;=> nil

by abhilater on 2017-05-11 ▶

;; apply feeds sequence items as variable args to the conj function ;; variable args gets converted to list in the function arg and hence conj ;; adds them as a list (apply #(conj [0 1] %&) [2 3 4 5]) ;;=> [0 1 (2 3 4 5)] ;; Partial offers are mechanism to feed the variable args as is to the conj ;; function effectively like (conj [] 2 3 4 5) (apply (partial conj [0 1]) [2 3 4 5]) ;;=> [0 1 2 3 4 5]

by ibercode on 2018-01-28 ▶

;;practical example (def add-domain (partial #(str % "@clojure.com"))) (add-domain "info") ;;"info@clojure.com"

by ibercode on 2018-02-16 ▶

(defn email-struct [username domain] (str username "@" domain)) (def build-email #(partial email-struct %)) ((build-email "info") "example.com") ;;"info@example.com"

by Hindol on 2019-04-24 ▶

;; partial does not gel well with pure java methods ;; Wrap Java method in Clojure fn (defn letter? [ch] (Character/isLetter ch)) ;; Idiomatic (filter letter? "hello, world!") ;; => (\h \e \l \l \o \w \o \r \l \d) ;; This works (filter (partial letter?) "hello, world!") ;; => (\h \e \l \l \o \w \o \r \l \d) ;; This also works (filter #(Character/isLetter %) "hello, world!") ;; => (\h \e \l \l \o \w \o \r \l \d) ;; This doesn't (filter (partial Character/isLetter) "hello, world!") ;; => Unable to find static field: isLetter in class java.lang.Character

by sulami on 2020-01-31 . May have evaluation errors. ▶

;; Beware that partial "bakes in" the original function and does not look it up ;; again at call time, which can be confusing when mocking. (defn foo [] "hit foo") ;; => #'user/foo (defn mock [] "hit the mock") ;; => #'user/mock (def par (partial foo)) ;; => #'user/par (with-redefs-fn {#'foo mock} #(foo)) ;; => "hit the mock" (with-redefs-fn {#'foo mock} #(par)) ;; => "hit foo"

by jvw-git on 2020-08-03 ▶

;; Partial application by calling partial significantly differs from partial ;; application by wrapping a function call in an anonymous function. ;; The code representing the to-be-applied function and to-be-applied-to arguments ;; - with the 'call to partial' approach ;; - is evaluated exactly once, when the call to partial is evaluated. ;; - is not evaluated when a call to the resulting function is evaluated. ;; - with the 'wrapped in an anonymous function' approach ;; - is not evaluated when the anonymous function is evaluated. ;; - is evaluated anew each time a call to the anonymous function is evaluated. ;; If there are side effects involved in obtaining the to-be-applied function or ;; to-be-applied-to arguments (because of with-redefs, this includes referring to a ;; var by providing a symbol), carefully consider which approach to take. (defn fetch-processing-fn! [] (prn "fetching...") (fn [entity] entity)) (defn load-entity! [id] (prn "loading...") :entity) (def top-level-fn-1 (partial (fetch-processing-fn!) (load-entity! 123))) ;; "fetching..." is printed. ;; "loading..." is printed. (top-level-fn-1) ;; Nothing is printed. (top-level-fn-1) ;; Nothing is printed. (def top-level-fn-2 #((fetch-processing-fn!) (load-entity! 123))) ;; Nothing is printed. (top-level-fn-2) ;; "fetching..." is printed. ;; "loading..." is printed. (top-level-fn-2) ;; "fetching..." is printed. ;; "loading..." is printed.

Note by roryokane

This function implements the concept of “currying�.

See also

• clojure.core/comp (15)
• clojure.core/juxt (7)
• clojure.core/apply (14)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.