Sequence Operations

(map f coll)
(map f c1 c2 & colls)
;; Applies function f to each element of coll(s)
;; With multiple collections, applies f to first of each, then second of each, etc.
;; Returns lazy sequence
;; Returns: clojure.lang.LazySeq

(mapv f coll)
(mapv f c1 c2 & colls)  
;; Like map but returns a vector instead of lazy seq
;; Returns: clojure.lang.IPersistentVector

(map-indexed f coll)
;; Like map but f takes (index, item) as arguments
;; Returns lazy sequence  
;; Returns: clojure.lang.LazySeq

(mapcat f & colls)
;; Equivalent to (apply concat (map f colls))
;; Returns lazy sequence
;; Returns: clojure.lang.LazySeq

(for [bindings*] expr)
;; List comprehension with optional :let, :when, :while clauses
;; bindings: [name coll :let [name expr] :when test :while test]
;; Returns lazy sequence
;; Returns: clojure.lang.LazySeq

(filter pred coll)
;; Returns lazy sequence of items for which pred returns true
;; Returns: clojure.lang.LazySeq

(filterv pred coll)
;; Like filter but returns vector
;; Returns: clojure.lang.IPersistentVector

(remove pred coll)
;; Returns lazy sequence of items for which pred returns false/nil
;; Returns: clojure.lang.LazySeq

(keep f coll)
;; Returns lazy sequence of non-nil results of (f item)
;; Returns: clojure.lang.LazySeq

(keep-indexed f coll)
;; Like keep but f takes (index, item) as arguments
;; Returns: clojure.lang.LazySeq

(distinct coll)
;; Returns lazy sequence of distinct elements
;; Returns: clojure.lang.LazySeq

(dedupe coll)
;; Returns lazy sequence with consecutive duplicates removed
;; Returns: clojure.lang.LazySeq

(reduce f coll)
(reduce f init coll)
;; Applies f to pairs: (f (f init first) second) ...
;; If no init provided, uses first element
;; Returns: Object

(reductions f coll)
(reductions f init coll) 
;; Returns lazy seq of intermediate reduce values
;; Returns: clojure.lang.LazySeq

(apply f args)
(apply f x args)
(apply f x y args)
(apply f x y z args)
(apply f a b c d & args)
;; Applies function f to argument list
;; Last argument must be a sequence
;; Returns: Object

(take n coll)
;; Returns lazy sequence of first n items
;; Returns: clojure.lang.LazySeq

(take-while pred coll)
;; Returns lazy sequence of successive items while pred is true
;; Returns: clojure.lang.LazySeq

(take-last n coll)
;; Returns seq of last n items
;; Returns: clojure.lang.ISeq

(drop n coll)
;; Returns lazy sequence without first n items  
;; Returns: clojure.lang.LazySeq

(drop-while pred coll)
;; Returns lazy sequence without successive items while pred is true
;; Returns: clojure.lang.LazySeq

(drop-last n? coll)
;; Returns lazy sequence without last n items (default n=1)
;; Returns: clojure.lang.LazySeq

(reverse coll)
;; Returns seq with elements in reverse order
;; Returns: clojure.lang.ISeq

(sort coll)
(sort comp coll)
;; Returns sorted sequence, optionally with comparator
;; Returns: clojure.lang.ISeq  

(sort-by keyfn coll)
(sort-by keyfn comp coll)
;; Returns sequence sorted by keyfn results
;; Returns: clojure.lang.ISeq

(shuffle coll)
;; Returns vector with items in random order
;; Returns: clojure.lang.IPersistentVector

(concat & xs)
;; Returns lazy concatenation of sequences
;; Returns: clojure.lang.LazySeq

(interleave c1 c2 & colls)
;; Returns lazy seq of first items, then second items, etc.
;; Returns: clojure.lang.LazySeq

(interpose sep coll)
;; Returns lazy seq with sep between each item
;; Returns: clojure.lang.LazySeq

(flatten x)
;; Takes nested structure and returns flattened seq
;; Returns: clojure.lang.ISeq

(partition n coll)
(partition n step coll)
(partition n step pad coll)
;; Returns lazy sequence of lists of n items each
;; step defaults to n, pad provides items for incomplete partition
;; Returns: clojure.lang.LazySeq

(partition-all n coll)
(partition-all n step coll)
;; Like partition but includes incomplete final partition
;; Returns: clojure.lang.LazySeq

(partition-by f coll)
;; Returns lazy sequence of lists split when (f item) changes
;; Returns: clojure.lang.LazySeq

(split-at n coll)
;; Returns vector of [(take n coll) (drop n coll)]
;; Returns: clojure.lang.IPersistentVector

(split-with pred coll)
;; Returns vector of [(take-while pred coll) (drop-while pred coll)]
;; Returns: clojure.lang.IPersistentVector

(group-by f coll)
;; Returns map of (f item) keys to vectors of items with that key
;; Returns: clojure.lang.IPersistentMap

(frequencies coll)
;; Returns map of items to their occurrence counts
;; Returns: clojure.lang.IPersistentMap

(zipmap keys vals)
;; Returns map with keys mapped to corresponding vals
;; Returns: clojure.lang.IPersistentMap

(some pred coll)
;; Returns first truthy result of (pred item), nil if none
;; Returns: Object or nil

(every? pred coll)
;; Returns true if pred is true for every item
;; Returns: boolean

(not-every? pred coll)
;; Returns false if pred is true for every item
;; Returns: boolean

(not-any? pred coll)
;; Returns true if pred is false for every item  
;; Returns: boolean

(nth coll index)
(nth coll index not-found)
;; Returns item at index, or not-found if out of bounds
;; Returns: Object

;; Transformation
(map inc [1 2 3 4])          ; => (2 3 4 5)
(map + [1 2 3] [4 5 6])      ; => (5 7 9)
(map-indexed vector [a b c])  ; => ([0 a] [1 b] [2 c])

;; Filtering  
(filter even? [1 2 3 4 5 6]) ; => (2 4 6)
(remove even? [1 2 3 4 5 6]) ; => (1 3 5)
(distinct [1 2 2 3 3 3])     ; => (1 2 3)

;; Reduction
(reduce + [1 2 3 4])         ; => 10
(reduce conj [] [1 2 3])     ; => [1 2 3]

;; Taking and dropping
(take 3 [1 2 3 4 5])         ; => (1 2 3)
(drop 2 [1 2 3 4 5])         ; => (3 4 5)
(take-while pos? [1 2 -1 3]) ; => (1 2)

;; Partitioning
(partition 2 [1 2 3 4 5 6])  ; => ((1 2) (3 4) (5 6))
(partition-by even? [1 3 2 4 5 7]) ; => ((1 3) (2 4) (5 7))

;; Grouping
(group-by even? [1 2 3 4 5 6]) ; => {false [1 3 5], true [2 4 6]}
(frequencies [:a :b :a :c :b :a]) ; => {:a 3, :b 2, :c 1}

;; List comprehension
(for [x (range 5)
      y (range 5)
      :when (< x y)]
  [x y])
; => ([0 1] [0 2] [0 3] [0 4] [1 2] [1 3] [1 4] [2 3] [2 4] [3 4])