Data Structures and Collections

(get map key)
(get map key not-found)
;; Returns value for key, or not-found/nil if key not present
;; Returns: Object

(get-in m ks)
(get-in m ks not-found)
;; Returns value in nested associative structure
;; ks is sequence of keys: (get-in {:a {:b 2}} [:a :b]) => 2
;; Returns: Object

(assoc map key val)
(assoc map key val & kvs)
;; Returns new map with key-value associations
;; Returns: clojure.lang.IPersistentMap

(assoc-in m ks v)
;; Returns new nested structure with value at key sequence
;; Returns: clojure.lang.IPersistentMap

(dissoc map & keys)
;; Returns new map without specified keys
;; Returns: clojure.lang.IPersistentMap

(update m k f & args)
;; Returns new map with (f (get m k) args) at key k
;; Returns: clojure.lang.IPersistentMap

(update-in m ks f & args)  
;; Returns new nested structure with f applied at key sequence
;; Returns: clojure.lang.IPersistentMap

(merge & maps)
;; Returns map with all key-value pairs from maps (right wins)
;; Returns: clojure.lang.IPersistentMap

(merge-with f & maps)
;; Like merge but uses f to combine values for duplicate keys
;; Returns: clojure.lang.IPersistentMap

(select-keys map keyseq)
;; Returns map containing only entries with keys in keyseq
;; Returns: clojure.lang.IPersistentMap

(keys map)
;; Returns sequence of map's keys
;; Returns: clojure.lang.ISeq

(vals map)
;; Returns sequence of map's values  
;; Returns: clojure.lang.ISeq

(find map key)
;; Returns MapEntry for key, or nil if not found
;; Returns: clojure.lang.MapEntry or nil

(contains? coll key)
;; Returns true if key is present in collection
;; For maps, tests for key presence; for vectors, tests valid indices
;; Returns: boolean

(vec coll)
;; Creates vector from collection
;; Returns: clojure.lang.IPersistentVector

(subvec v start)
(subvec v start end)
;; Returns subvector from start (inclusive) to end (exclusive)
;; Returns: clojure.lang.IPersistentVector

(rseq rev)
;; Returns reverse sequence of reversible collection
;; Works efficiently with vectors  
;; Returns: clojure.lang.ISeq

(peek coll)
;; Returns last item of vector, first item of list/seq
;; Returns: Object

(pop coll)
;; Returns new collection without last item (vector) or first item (list)
;; Returns: same type as coll

(disj set & keys)
;; Returns new set without specified keys
;; Returns: clojure.lang.IPersistentSet

(clojure.set/union & sets)
;; Returns set that is union of input sets
;; Returns: clojure.lang.IPersistentSet

(clojure.set/intersection & sets)
;; Returns set that is intersection of input sets  
;; Returns: clojure.lang.IPersistentSet

(clojure.set/difference s1 & sets)
;; Returns set that is s1 without elements of remaining sets
;; Returns: clojure.lang.IPersistentSet

(clojure.set/subset? set1 set2)
;; Returns true if set1 is subset of set2
;; Returns: boolean

(clojure.set/superset? set1 set2)
;; Returns true if set1 is superset of set2
;; Returns: boolean

(clojure.set/select pred set)
;; Returns set of elements for which pred is true
;; Returns: clojure.lang.IPersistentSet

(clojure.set/project rel keys)
;; Returns set of maps with only specified keys from relation
;; Returns: clojure.lang.IPersistentSet

(clojure.set/rename-keys map kmap)
;; Returns map with keys renamed according to kmap
;; Returns: clojure.lang.IPersistentMap

(clojure.set/rename rel kmap)
;; Returns set of maps with keys renamed in each map
;; Returns: clojure.lang.IPersistentSet

(clojure.set/index rel keys)
;; Returns map indexed by specified keys from relation
;; Returns: clojure.lang.IPersistentMap

(clojure.set/map-invert m)
;; Returns map with keys and values swapped
;; Returns: clojure.lang.IPersistentMap

(clojure.set/join rel1 rel2)
(clojure.set/join rel1 rel2 km)
;; Returns natural join of relations, optionally with key map
;; Returns: clojure.lang.IPersistentSet

(into to from)
(into to xform from)
;; Returns new collection with from items added to to
;; Optional transducer xform transforms items during insertion
;; Returns: same type as to

(vec coll)
;; Returns vector of collection items
;; Returns: clojure.lang.IPersistentVector

(set coll)
;; Returns set of collection items  
;; Returns: clojure.lang.IPersistentSet

(seq coll)
;; Returns seq of collection items, nil if empty
;; Returns: clojure.lang.ISeq or nil

(lazy-seq & body)
;; Creates lazy sequence from body
;; Body should return nil or sequence
;; Returns: clojure.lang.LazySeq

(empty? coll)
;; Returns true if collection has no items
;; Returns: boolean

(not-empty coll)
;; Returns coll if not empty, nil otherwise  
;; Returns: coll or nil

(distinct? & xs)
;; Returns true if no two arguments are equal
;; Returns: boolean

(sorted? coll)
;; Returns true if collection is sorted
;; Returns: boolean

(reversible? coll)
;; Returns true if collection implements Reversible
;; Returns: boolean

(indexed? coll)
;; Returns true if collection supports efficient random access
;; Returns: boolean

(range)
(range end)
(range start end)  
(range start end step)
;; Returns lazy sequence of numbers
;; Default: infinite from 0, or 0 to end, or start to end by step
;; Returns: clojure.lang.LongRange or clojure.lang.LazySeq

(repeat x)
(repeat n x)
;; Returns lazy infinite sequence of x, or sequence of n x's
;; Returns: clojure.lang.Repeat or clojure.lang.LazySeq

(repeatedly f)
(repeatedly n f)
;; Returns lazy sequence of calls to f (no args)
;; Returns: clojure.lang.LazySeq

(cycle coll)
;; Returns lazy infinite sequence that cycles through coll
;; Returns: clojure.lang.LazySeq

(iterate f x)
;; Returns lazy infinite sequence of x, (f x), (f (f x)), ...
;; Returns: clojure.lang.LazySeq

;; Vector destructuring
[a b c] ; binds first three elements
[a b & rest] ; binds first two, rest gets remaining as seq
[a _ c] ; underscore ignores second element  
[a b :as all] ; :as binds entire vector

;; Map destructuring  
{:keys [name age]} ; binds name and age from map keys
{name :name, age :age} ; explicit key mapping
{:keys [name age] :as person} ; :as binds entire map
{:keys [name age] :or {age 0}} ; :or provides defaults

;; Map operations
(def person {:name "Alice" :age 30 :city "NYC"})
(get person :name)                    ; => "Alice"  
(assoc person :email "alice@ex.com")  ; => {:name "Alice" :age 30 :city "NYC" :email "alice@ex.com"}
(dissoc person :city)                 ; => {:name "Alice" :age 30}
(update person :age inc)              ; => {:name "Alice" :age 31 :city "NYC"}

;; Nested operations
(def data {:users [{:name "Alice" :age 30} {:name "Bob" :age 25}]})
(get-in data [:users 0 :name])        ; => "Alice"
(assoc-in data [:users 0 :age] 31)    ; => {:users [{:name "Alice" :age 31} {:name "Bob" :age 25}]}

;; Vector operations  
(def v [1 2 3 4 5])
(peek v)        ; => 5
(pop v)         ; => [1 2 3 4]
(subvec v 1 3)  ; => [2 3]

;; Set operations
(def s1 #{1 2 3})
(def s2 #{3 4 5})
(clojure.set/union s1 s2)        ; => #{1 2 3 4 5}
(clojure.set/intersection s1 s2) ; => #{3}

;; Collection conversion
(into [] (range 5))   ; => [0 1 2 3 4]
(into #{} [1 2 2 3])  ; => #{1 2 3} 
(vec (range 5))       ; => [0 1 2 3 4]

;; Destructuring
(let [[a b c] [1 2 3 4 5]]
  [a b c])            ; => [1 2 3]

(let [{:keys [name age]} {:name "Alice" :age 30}]
  [name age])         ; => ["Alice" 30]

;; Sequence creation
(take 5 (range))           ; => (0 1 2 3 4)
(take 3 (repeat "hello"))  ; => ("hello" "hello" "hello")  
(take 5 (cycle [1 2]))     ; => (1 2 1 2 1)
(take 4 (iterate inc 0))   ; => (0 1 2 3)