clojure.core/comp

View this page on ClojureDocs

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

([] [f] [f g] [f g & fs])

Takes a set of functions and returns a fn that is the composition of those fns. The returned fn takes a variable number of args, applies the rightmost of fns to the args, the next fn (right-to-left) to the result, etc.

Examples

by citizen428 on 2010-07-31 ▶

(def negative-quotient (comp - /)) ;; #'user/negative-quotient (negative-quotient 8 3) ;;=> -8/3 (def concat-and-reverse (comp (partial apply str) reverse str)) ;; #'user/concat-and-reverse (concat-and-reverse "hello" "clojuredocs") ;;=> "scoderujolcolleh"

by zpinter on 2010-12-16 ▶

((comp str +) 8 8 8) ;;=> "24"

by semperos on 2011-01-28 ▶

(map (comp - (partial + 3) (partial * 2)) [1 2 3 4]) ;;=> (-5 -7 -9 -11)

by MrHus on 2011-05-19 ▶

(filter (comp not zero?) [0 1 0 2 0 3 0 4]) ;;=> (1 2 3 4)

by yasuto on 2011-05-25 . May have evaluation errors. ▶

;; make a struct 'goods'. it assumes that every goods has ;; its id number and price. (defstruct goods :id :price) ;; generate data. (def data (map #(struct goods %1 %2) (shuffle (range 0 10)) (shuffle (into (range 100 500 100) (range 100 500 100))))) (defn comp-goods-price "a compare function by :price of the struct 'goods.' the sort order is that the lower price is superior to the higher one and if the price is same, the lower id is superior to the higher one." [el1 el2] (if (or (< (:price el1) (:price el2)) (and (= (:price el1) (:price el2)) (< (:id el1) (:id el2)))) true false)) ;; The shuffle will cause your results to differ. data ;;=> ({:id 1, :price 300} {:id 6, :price 100} ;; {:id 3, :price 100} {:id 4, :price 400} ;; {:id 0, :price 300} {:id 2, :price 200} ;; {:id 5, :price 200} {:id 8, :price 400}) (sort (comp comp-goods-price) data) ;;=> ({:id 3, :price 100} {:id 6, :price 100} ;; {:id 2, :price 200} {:id 5, :price 200} ;; {:id 0, :price 300} {:id 1, :price 300} ;; {:id 4, :price 400} {:id 8, :price 400}) (sort-by :price < data) ; compare this with the above. ;;=> ({:id 6, :price 100} {:id 3, :price 100} ;; {:id 2, :price 200} {:id 5, :price 200} ;; {:id 1, :price 300} {:id 0, :price 300} ;; {:id 4, :price 400} {:id 8, :price 400}) ;; Yet another example of 'comp' by PriorityBlockingQueue. (import [java.util.concurrent PriorityBlockingQueue]) ;; java.util.concurrent.PriorityBlockingQueue (def pqdata (new PriorityBlockingQueue 8 (comp comp-goods-price))) ;; #'user/pqdata (doseq [x data] (.add pqdata x)) ;;=> nil (dotimes [_ 8] (println (.poll pqdata))) ;; {:id 3, :price 100} ;; {:id 6, :price 100} ;; {:id 2, :price 200} ;; {:id 5, :price 200} ;; {:id 0, :price 300} ;; {:id 1, :price 300} ;; {:id 4, :price 400} ;; {:id 8, :price 400} ;;=> nil

by shockbob on 2011-08-22 . May have evaluation errors. ▶

(def countif (comp count filter)) #'user/countif (countif even? [2 3 1 5 4]) ;;=> 2

by Will on 2012-08-09 ▶

; Get 2nd to last element from a list ( (comp second reverse) '("a" 2 7 "b")) ;;=> 7

by phreed on 2015-12-10 ▶

; We need an example that composes more than just two functions. ; The following example is an overly complicated reimplementation of 'nth' ; but it does show the composition of an arbitrary number of functions (rest). ( #((apply comp first (repeat %2 rest)) %1) [1 2 3 4 5 6] 3 ) ;;=> 4

by purukaushik on 2017-02-07 ▶

; `comp`-ing maps, filters with a little help from our friend `partial` ; the following function filters numbers in a `coll` if it is divisible by 3 ; then on that filtered `coll`, multiplies all by 2 ; a little helper to find if a number is div by 3 ; also comp-ed (def mod3nz? (comp not zero? #(mod % 3))) ; now for that elusive function that muls by 2 after filter those not div by 3 (def mul-2-nd-3 "Takes a seq of numbers, filters those not divisible by 3 and muls them by 2" (comp (partial map #(* % 2)) (partial filter mod3nz?))) (mul-2-nd-3 [16 15 30 43]) ;; => (32 86)

by bsifou on 2017-02-11 ▶

; Split a number into sequence of it's digits ((comp (partial map (comp read-string str)) str) 33) ;;=> (3 3)

by merliecat on 2017-06-19 ▶

;; Keywords are used as functions to access data in maps. (:foo {:foo "bar"}) ;;=> "bar" ;; With a nested data structure, it is common to use ;; several keywords in sequence to navigate the hierarchy. (def my-data {:this {:that {:the-other "val"}}}) ;;=> #'user/my-data (-> my-data :this :that :the-other) ;;=> "val" ;; Since keywords are functions, ;; they can be 'comp'ed just like any other function. (def those (comp :the-other :that :this)) ; Note: reverse order ;;=> #'user/those (those my-data) ;;=> "val" ;; The composed keyword-sequence can be used with other keywords: - (def my-data-2 {:this {:that {:the-other {:a "apple" :b "banana"}}}}) ;;=> #'user/my-data-2 (let [a (-> my-data-2 those :a) b (-> my-data-2 those :b)] (str "These: " a ", " b)) ;;=> "These: apple, banana"

by elect000 on 2017-10-24 ▶

;; ((comp func1 func2) data) mean ... ;; (-> data func2 func1) ;; so, ((comp (partial * 3) inc) 1) ;; means (* 3 (inc 1)) ;; advanced ... ((comp seq re-seq) #"(\w+)=(\S+)" "foo=bar") ;; (["foo=bar" "foo" "bar"]) (seq (re-seq #"(\w+)=(\S+)" "foo=bar")) ;; * "#(\w+)..." and "foo=..." are arguments for #re-seq

by phreed on 2017-11-07 ▶

;; comp is the transducer equivalent to thrush ;; An example of using the "thread-last" macro to get ;; the sum of the first 10 even squares. (->> (range) (map #(* % %)) (filter even?) (take 10) (reduce +)) ;;=> 1140 ;; Many the seq functions now produce transducers. ;; `reduce` does not but has been replaced with `transduce`. (transduce (comp (map #(* % %)) (filter even?) (take 10)) + 0 (range) ) ;;=> 1140

by ibercode on 2018-02-06 ▶

;;trim will remove the white spaces and return a new string which will be passed ;;to the second function capitalize which will return a new string ((comp clojure.string/capitalize clojure.string/trim) " london ") ;;"London"

by ibercode on 2018-02-06 ▶

(def my-car {:name "audi" :data {:cc 2990 :bhp 350}}) ((comp :bhp :data) my-car) ;;350 ;;which is the equivalent of (:bhp (:data my-car)) ;;350

by Jjunior130 on 2018-09-13 . May have evaluation errors. ▶

(require '[reagent.core :as r]) (def float-parsable? (comp not js/isNaN js/parseFloat)) (def find-parsable-or-nil (comp first (partial re-find #"(\-?\d+\.)?\d+([eE][-+]?\d+)?"))) (defn number-input "HTML input element for number only input" [value] [:input {:value @value :type "text" :on-change (comp #(when-let [new-value %] (reset! value new-value)) (fn [new-value] (cond (empty? new-value) "" (float-parsable? new-value) new-value :otherwise (find-parsable-or-nil new-value))) (fn [target] (.-value target)) (fn [event] (.-target event)))}]) (def value (r/atom "")) (defn demo [] [:div ; Displays NaN when value is "", displays a number otherwise. (-> @value js/parseFloat str) [:br] [number-input value]])

by luontola on 2019-03-15 ▶

; Demonstrating the order of parameters vs. normal function application. (def x {:bar {:foo 42}}) (:foo (:bar x)) ;;=> 42 ((comp :foo :bar) x) ;;=> 42

by nbardiuk on 2021-03-14 ▶

; Without arguments returns identity function (identical? (comp) identity) ;;=> true ((comp) :arg) ;;=> :arg

See also

• clojure.core/partial (10)
• clojure.core/juxt (7)
• clojure.core/every-pred (2)

---

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