Clojure Core

Namespaces

clojure
- core
  - protocols
- inspector
- java
  - browse
  - io
  - javadoc
  - shell
- main
- pprint
- repl
- set
- stacktrace
- string
- template
- test
  - junit
  - tap
- walk
- xml
- zip

You're viewing version 1.2.0 of reduce. The latest stable version of Clojure Core is 1.3.0.

1.2.0

1.2.0
1.3.0

reduce

f should be a function of 2 arguments. If val is not supplied,
returns the result of applying f to the first 2 items in coll, then
applying f to that result and the 3rd item, etc. If coll contains no
items, f must accept no arguments as well, and reduce returns the
result of calling f with no arguments. If coll has only 1 item, it
is returned and f is not called. If val is supplied, returns the
result of applying f to val and the first item in coll, then
applying f to that result and the 2nd item, etc. If coll contains no
items, returns val and f is not called.

8 Examples top

link | changes
```
user=> (reduce + [1 2 3 4 5])
15
user=> (reduce + [])
0
user=> (reduce + 1 [])
1
user=> (reduce + 1 [2 3])
6
```
user=> (reduce + [1 2 3 4 5]) 15 user=> (reduce + []) 0 user=> (reduce + 1 []) 1 user=> (reduce + 1 [2 3]) 6
link | changes
```
;converting a vector to a set
user=> (reduce conj #{} [:a :b :c])
#{:a :c :b}
```
;converting a vector to a set user=> (reduce conj #{} [:a :b :c]) #{:a :c :b}
link | changes
```
;; Create a word frequency map out of a large string s.

;; `s` is a long string containing a lot of words :)
(reduce #(assoc %1 %2 (inc (%1 %2 0)))
        {}
        (re-seq #"\w+" s))

; (This can also be done using the `frequencies` function.)
```
;; Create a word frequency map out of a large string s. ;; `s` is a long string containing a lot of words :) (reduce #(assoc %1 %2 (inc (%1 %2 0))) {} (re-seq #"\w+" s)) ; (This can also be done using the `frequencies` function.)
link | changes
```
;; Calculate primes until 1000

user=> (reduce
         (fn [primes number]
           (if (some zero? (map (partial mod number) primes))
             primes
             (conj primes number)))
         [2]
         (take 1000 (iterate inc 3)))

[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 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997]
```
;; Calculate primes until 1000 user=> (reduce (fn [primes number] (if (some zero? (map (partial mod number) primes)) primes (conj primes number))) [2] (take 1000 (iterate inc 3))) [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 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997]
link | changes
```
;; Add one sequence to another:
user=> (reduce conj [1 2 3] [4 5 6])
[1 2 3 4 5 6]
```
;; Add one sequence to another: user=> (reduce conj [1 2 3] [4 5 6]) [1 2 3 4 5 6]
link | changes
```
; Combine a set of collections into a single collection
user=> (reduce into [[1 2 3] [:a :b :c] '([4 5] 6)])
[1 2 3 :a :b :c [4 5] 6]
```
; Combine a set of collections into a single collection user=> (reduce into [[1 2 3] [:a :b :c] '([4 5] 6)]) [1 2 3 :a :b :c [4 5] 6]
link | changes
```
(defn key-pres?
    "This function accepts a value (cmp-val) and a vector of vectors
    (parsed output from clojure-csv) and returns the match value
    back if found and nil if not found. 

    Using reduce, the function searches every vector row to see 
    if cmp-val is at the col-idx location in the vector."

    [cmp-val cmp-idx csv-data]
    (reduce
        (fn [ret-rc csv-row]
            (if (= cmp-val (nth csv-row col-idx nil))
                    (conj ret-rc cmp-val)))
        [] 
        csv-data))
```
(defn key-pres? "This function accepts a value (cmp-val) and a vector of vectors (parsed output from clojure-csv) and returns the match value back if found and nil if not found. Using reduce, the function searches every vector row to see if cmp-val is at the col-idx location in the vector." [cmp-val cmp-idx csv-data] (reduce (fn [ret-rc csv-row] (if (= cmp-val (nth csv-row col-idx nil)) (conj ret-rc cmp-val))) [] csv-data))
link | changes
```
(defn reduce-csv-row
    "Accepts a csv-row (a vector) a list of columns to extract, 
     and reduces (and returns) a csv-row to a subset based on 
     selection using the values in col-nums (a vector of integer 
     vector positions.)"

    [csv-row col-nums]

    (reduce
        (fn [out-csv-row col-num]
            ; Don't consider short vectors containing junk.
            (if-not (<= (count csv-row) 1)
                (conj out-csv-row (nth csv-row col-num nil))))
        []
        col-nums))
```
(defn reduce-csv-row "Accepts a csv-row (a vector) a list of columns to extract, and reduces (and returns) a csv-row to a subset based on selection using the values in col-nums (a vector of integer vector positions.)" [csv-row col-nums] (reduce (fn [out-csv-row col-num] ; Don't consider short vectors containing junk. (if-not (<= (count csv-row) 1) (conj out-csv-row (nth csv-row col-num nil)))) [] col-nums))

Source clojure/core.clj:773 top

(def
    ^{:arglists '([f coll] [f val coll])
      :doc "f should be a function of 2 arguments. If val is not supplied,
  returns the result of applying f to the first 2 items in coll, then
  applying f to that result and the 3rd item, etc. If coll contains no
  items, f must accept no arguments as well, and reduce returns the
  result of calling f with no arguments.  If coll has only 1 item, it
  is returned and f is not called.  If val is supplied, returns the
  result of applying f to val and the first item in coll, then
  applying f to that result and the 2nd item, etc. If coll contains no
  items, returns val and f is not called."
      :added "1.0"}    
    reduce
     (fn r
       ([f coll]
             (let [s (seq coll)]
               (if s
                 (r f (first s) (next s))
                 (f))))
       ([f val coll]
          (let [s (seq coll)]
            (if s
              (if (chunked-seq? s)
                (recur f 
                       (.reduce (chunk-first s) f val)
                       (chunk-next s))
                (recur f (f val (first s)) (next s)))
              val)))))

Vars in clojure.core/reduce: chunk-first chunk-next chunked-seq? first fn let next val

Used in 100 other vars (expand)

max-key get-in import + * - / frequencies destructure into replace reverse max min-key group-by ancestors merge-with juxt merge min file rename-keys union select join intersection map-invert difference index join-fixtures add-items ensure-relation predicate-map make-database rules-set apply-rules-set add-tuples project-literal magic-transform generate-all-namespaces-action-script max min post-ordered-nodes headers file with-system-properties file safe-get-in m-seq m-reduce m-chain choose sample-mean-variance sample sample-sum sample-mean sample-reduce summarize with-system-properties frequencies group-by frequencies group-by re-gsub join-fixtures flatten-map mapcat-chain parse-multipart-params bind-columns plus minus div kronecker mult mmult pow grid-apply conj-cols query-to-pred conj-rows atan2 bind-rows to-matrix hessian gradient tally do-> at* unmunge simple-completions scan-paths completions swank-version tree-map remove-known-keys group-container-args shelf general-panel stack frame

Comments top

1 comment(s) for reduce.

JoshuaEckroth

link

clojure.core/reduce seems to be a special case of a function that's defined twice in core.clj, and the first definition (at the line cited above: 773) is just a temporary definition; the real definition is later at line 5323, which contains the docstring.

ClojureDocs(beta)