高阶函数 #

(map inc [1 2 3 4 5])

(filter even? [1 2 3 4 5 6])

(reduce + [1 2 3 4 5])

(defn make-multiplier [n]
  (fn [x] (* n x)))

(def triple (make-multiplier 3))

(triple 5)

(map inc [1 2 3 4 5])

(map #(* % %) [1 2 3 4 5])

(map str [1 2 3])

(map + [1 2 3] [10 20 30])

(map vector [1 2 3] [:a :b :c])

(map str ["a" "b" "c"] [1 2 3])

(map (fn [[k v]] [k (* v 2)]) {:a 1 :b 2 :c 3})

(map-keys str {:a 1 :b 2})

(map-vals inc {:a 1 :b 2})

(map-indexed vector [:a :b :c])

(map-indexed (fn [i v] [i (* v 2)]) [1 2 3 4])

(mapcat reverse [[1 2 3] [4 5 6]])

(mapcat (fn [x] [x x]) [1 2 3])

(filter even? [1 2 3 4 5 6])

(filter #(< % 4) [1 2 3 4 5 6])

(filter string? [1 "a" 2 "b" 3 "c"])

(remove even? [1 2 3 4 5 6])

(remove nil? [1 nil 2 nil 3])

(filterv even? [1 2 3 4 5 6])

(keep #(when (even? %) (* % 2)) [1 2 3 4 5])

(keep :a [{:a 1} {:b 2} {:a 3}])

(keep-indexed (fn [i v] (when (even? i) v)) [:a :b :c :d])

(reduce + [1 2 3 4 5])

(reduce * [1 2 3 4 5])

(reduce str ["a" "b" "c"])

(reduce + 0 [1 2 3 4 5])

(reduce + 100 [1 2 3])

(reduce conj [] [1 2 3])

(reduce (fn [m [k v]]
          (assoc m k v))
        {}
        [[:a 1] [:b 2] [:c 3]])

(reduce (fn [s x]
          (conj s x))
        #{}
        [1 2 3 2 1])

(reduce-kv (fn [m k v]
             (assoc m k (* v 2)))
           {}
           {:a 1 :b 2 :c 3})

(reductions + [1 2 3 4 5])

(reductions conj [] [1 2 3])

(def process (comp str/upper-case str/reverse))

(process "hello")

(def calculate (comp inc #(* % 2)))

(calculate 5)

(def pipeline
  (comp
    (partial map inc)
    (partial filter even?)
    (partial reduce +)))

(pipeline [1 2 3 4 5])

(-> "hello"
    str/upper-case
    str/reverse)

(-> {:a {:b {:c 1}}}
    :a
    :b
    :c)

(->> [1 2 3 4 5]
     (map inc)
     (filter even?)
     (reduce +))

(->> "hello world"
     (str/split #" ")
     (map str/upper-case)
     (str/join "-"))

(some-> {:a {:b 1}}
        :a
        :b
        inc)

(some-> {:a {:b 1}}
        :a
        :c
        inc)

(defn process [x opts]
  (cond-> x
    (:double opts) (* 2)
    (:add-one opts) inc
    (:negate opts) -))

(process 5 {:double true :add-one true})

(every? even? [2 4 6 8])

(every? pos? [1 2 3])

(every? string? ["a" "b" "c"])

(some even? [1 3 5 6 7])

(some #{:a :b} [:c :d :a :e])

(some #(when (even? %) (* % 2)) [1 3 5 6 7])

(not-every? even? [1 2 3 4 5])

(not-any? neg? [1 2 3 4 5])

(not-any? nil? [1 2 3])

(take 5 (iterate inc 0))

(take 10 (iterate #(* % 2) 1))

(take 5 (repeatedly rand))

(take 3 (repeatedly #(rand-int 100)))

(take 10 (cycle [1 2 3]))

(take 5 (repeat :x))

(repeat 3 "hello")

(def xform
  (comp
    (map inc)
    (filter even?)
    (take 5)))

(def xform
  (comp
    (map inc)
    (filter even?)))

(sequence xform [1 2 3 4 5 6 7 8])

(into [] xform [1 2 3 4 5 6 7 8])

(transduce xform + 0 [1 2 3 4 5 6 7 8])

(def xform
  (comp
    (map #(* % %))
    (filter even?)
    (take 3)))

(sequence xform (range 10))

(into [] xform (range 10))

(defn process-users [users]
  (->> users
       (filter #(> (:age %) 18))
       (map #(select-keys % [:name :email]))
       (sort-by :name)
       (take 10)))

(process-users
  [{:name "Bob" :age 20 :email "bob@example.com"}
   {:name "Alice" :age 25 :email "alice@example.com"}
   {:name "Charlie" :age 15 :email "charlie@example.com"}])

(defn word-frequency [text]
  (->> text
       (str/lower-case)
       (re-seq #"\w+")
       (frequencies)
       (sort-by val >)
       (take 10)))

(word-frequency "Hello world hello Clojure world world")

(defn group-by-category [items]
  (->> items
       (group-by :category)
       (map (fn [[k v]] {:category k :count (count v) :items v}))
       (sort-by :count >)))

(group-by-category
  [{:name "A" :category :x}
   {:name "B" :category :y}
   {:name "C" :category :x}])

(defn tree-map [f tree]
  (if (coll? tree)
    (map #(tree-map f %) tree)
    (f tree)))

(tree-map inc [1 [2 3] [[4 5] 6]])