clojure.core/keep

View this page on ClojureDocs

Type: function Added: Clojure 1.2 Examples: 8 Runnable: 8

([f] [f coll])

Returns a lazy sequence of the non-nil results of (f item). Note, this means false return values will be included. f must be free of side-effects. Returns a transducer when no collection is provided.

Examples

by dpritchett on 2010-07-14 ▶

(keep even? (range 1 10)) ;;=> (false true false true false true false true false)

by yasuto on 2011-05-25 ▶

;; comparisons among keep, filter, map and for. (keep #(when (odd? %) %) (range 10)) ;;=> (1 3 5 7 9) (map #(when (odd? %) %) (range 10)) ;;=> (nil 1 nil 3 nil 5 nil 7 nil 9) (for [ x (range 10) :when (odd? x)] x) ;;=> (1 3 5 7 9) (filter odd? (range 10)) ;;=> (1 3 5 7 9)

by yasuto on 2011-05-25 ▶

;; Sieve of Eratosthenes by using 'keep'. (defn keep-mcdr [f coll] (lazy-seq (when-let [x (first coll)] (cons x (keep-mcdr f (f x (rest coll))))))) (defn prime-number [n] (cons 1 (keep-mcdr (fn[x xs] (if (not-empty xs) (keep #(if-not (zero? (rem % x)) %) xs))) (range 2 n)))) (prime-number 100) ;;=> (1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)

by miner on 2014-12-20 ▶

(keep seq [() [] '(1 2 3) [:a :b] nil]) ;;=> ((1 2 3) (:a :b))

by num1 on 2015-04-05 ▶

;; `keep` is useful with maps: (keep {:a 1, :b 2, :c 3} [:a :b :d]) ;;=> (1 2)

by dkinzer on 2015-06-17 ▶

;; A set will work as a predicate for another set. (keep #{0 1 2 3} #{2 3 4 5}) ;;=> (3 2)

by huahaiy on 2016-09-09 ▶

;; keep returns the results of predicates, ;; filter returns the original values of collection (keep (fn [[k _]] (#{:a :b} k)) {:a 1 :b 2 :c 3}) ;;=> (:a :b) (filter (fn [[k _]] (#{:a :b} k)) {:a 1 :b 2 :c 3}) ;;=> ([:a 1] [:b 2])

by blue0513 on 2020-05-29 ▶

;; keep rejects nil from results (keep #(when (number? %) %) [1 "a" 2 "c"]) ;; => (1 2) (map #(when (number? %) %) [1 "a" 2 "c"]) ;; => (1 nil 2 nil) (remove nil? (map #(when (number? %) %) [1 "a" 2 "c"])) ;; => (1 2)

Note by miner

Note the difference between filter and keep. filter returns the original items in a collection that satisfy the predicate. keep returns the non-nil results of the given function.

Note by Dimagog

keep is like a map that filters out nil values produced by f and could be defined as:

(def my-keep (comp (partial remove nil?) map))

or, perhaps more traditionally:

(defn my-keep [& args]
  (remove nil? (apply map args)))

Note by bfontaine

Note that, unlike map, keep doesn’t accept multiple collections:

(filter identity (map get [{:a 1} {:b 2} {:d 3}] [:a :b :c]))
; => (1 2)

(keep get [{:a 1} {:b 2} {:d 3}] [:a :b :c])
; => ArityException Wrong number of args (3) passed to: core/keep

Note by MicahElliott

It's useful to consider filter and remove as a pair of complementary/similar functions that both return the original items, whereas keep is rather specialized/different.

See also

• clojure.core/keep-indexed (5)
• clojure.core/map (13)
• clojure.core/filter (6)
• clojure.core/remove (6)

---

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