'(a b :name 12.5) ;; list

['a 'b :name 12.5] ;; vector

{:name "Chas" :age 31} ;; map

#{1 2 3} ;; set

{Math/PI "~3.14"

[:composite "key"] 42

nil "nothing"} ;; another map

#{{:first-name "chas" :last-name "emerick"}

{:first-name "brian" :last-name "carper"}

{:first-name "christophe" :last-name "grand"}} ;; a set of maps

(def v [1 2 3])

(conj v 4)

(conj v 4 5)

(seq v)

(def m {:a 5 :b 6})

(conj m [:c 7])

(seq m)

(def s #{1 2 3})

(conj s 10)

(conj s 3 4)

(seq s)

(def lst '(1 2 3))

(conj lst 0)

(conj lst 0 -1)

(seq lst)

(into v [4 5])

(into m [[:c 7] [:d 8]])

(into #{1 2} [2 3 4 5 3 3 2])

(into [1] {:a 1 :b 2})

(conj '(1 2 3) 4)

(into '(1 2 3) [:a :b :c])

(defn swap-pairs

[sequential]

(into (empty sequential)

(interleave

(take-nth 2 (drop 1 sequential))

(take-nth 2 sequential))))

(swap-pairs (apply list (range 10)))

(swap-pairs (apply vector (range 10)))

(defn map-map

[f m]

(into (empty m)

(for [[k v] m]

[k (f v)])))

(map-map inc (hash-map :z 5 :c 6 :a 0))

(map-map inc (sorted-map :z 5 :c 6 :a 0))

(count [1 2 3])

(count {:a 1 :b 2 :c 3})

(count #{1 2 3})

(count '(1 2 3))

(seq "Clojure")

(seq {:a 5 :b 6})

(seq (java.util.ArrayList. (range 5)))

(seq (into-array ["Clojure" "Programming"]))

(seq [])

(seq nil)

(map str "Clojure")

(set "Programming")

(first "Clojure")

(rest "Clojure")

(next "Clojure")

(rest [1])

(next [1])

(rest nil)

(next nil)

(= (next x)

(seq (rest x)))

(doseq [x (range 3)]

(println x))

(let [r (range 3)

rst (rest r)]

(prn (map str rst))

(prn (map #(+ 100 %) r))

(prn (conj r -1) (conj rst 42)))

(let [s (range 1e6)]

(time (count s)))

(let [s (apply list (range 1e6))]

(time (count s)))

(cons 0 (range 1 5))

(cons :a [:b :c :d])

(cons 0 (cons 1 (cons 2 (cons 3 (range 4 10)))))

(list* 0 1 2 3 (range 4 10))

(lazy-seq [1 2 3])

(defn random-ints

"Returns a lazy seq of random integers in the range [0,limit)."

[limit]

(lazy-seq

(cons (rand-int limit)

(random-ints limit))))

(take 10 (random-ints 50))

(defn random-ints

[limit]

(lazy-seq

(println "realizing random number")

(cons (rand-int limit)

(random-ints limit))))

(def rands (take 10 (random-ints 50)))

(first rands)

(nth rands 3)

(count rands)

(count rands)

(repeatedly 10 (partial rand-int 50))

(def x (next (random-ints 50)))

(def x (rest (random-ints 50)))

(let [[x & rest] (random-ints 50)])

(dorun (take 5 (random-ints 50)))

(doc iterate)

(doc reverse)

(apply str (remove (set "aeiouy")

"vowels are useless! or maybe not..."))

(split-with neg? (range -5 5))

(let [[t d] (split-with #(< % 12) (range 1e8))]

[(count d) (count t)])

(let [[t d] (split-with #(< % 12) (range 1e8))]

[(count t) (count d)])

(def m {:a 1, :b 2, :c 3})

(get m :b)

(get m :d)

(get m :d "not-found")

(assoc m :d 4)

(dissoc m :b)

(assoc m

:x 4

:y 5

:z 6)

(dissoc m :a :c)

(def v [1 2 3])

(get v 1)

(get v 10)

(get v 10 "not-found")

(assoc v

1 4

0 -12

2 :p)

(assoc v 3 10)

(get #{1 2 3} 2)

(get #{1 2 3} 4)

(get #{1 2 3} 4 "not-found")

(when (get #{1 2 3} 2)

(println "it contains `2`!"))

(contains? [1 2 3] 0)

(contains? {:a 5 :b 6} :b)

(contains? {:a 5 :b 6} 42)

(contains? #{1 2 3} 1)

(contains? [1 2 3] 3)

(contains? [1 2 3] 2)

(contains? [1 2 3] 0)

(get "Clojure" 3)

(contains? (java.util.HashMap.) "not-there")

(get (into-array [1 2 3]) 0)

(get {:ethel nil} :lucy)

(get {:ethel nil} :ethel)

(find {:ethel nil} :lucy)

(find {:ethel nil} :ethel)

(if-let [e (find {:a 5 :b 6} :a)]

(format "found %s => %s" (key e) (val e))

"not found")

(if-let [[k v] (find {:a 5 :b 6} :a)]

(format "found %s => %s" k v)

"not found")

(nth [:a :b :c] 2)

(get [:a :b :c] 2)

(nth [:a :b :c] 3)

(get [:a :b :c] 3)

(nth [:a :b :c] -1)

(get [:a :b :c] -1)

(nth [:a :b :c] -1 :not-found)

(get [:a :b :c] -1 :not-found)

(get 42 0)

(nth 42 0)

(conj '() 1)

(conj '(2 1) 3)

(peek '(3 2 1))

(pop '(3 2 1))

(pop '(1))

(conj [] 1)

(conj [1 2] 3)

(peek [1 2 3])

(pop [1 2 3])

(pop [1])

(get #{1 2 3} 2)

(get #{1 2 3} 4)

(get #{1 2 3} 4 "not-found")

(disj #{1 2 3} 3 1)

(def sm (sorted-map :z 5 :x 9 :y 0 :b 2 :a 3 :c 4))

sm

(rseq sm)

(subseq sm <= :c)

(subseq sm > :b <= :y)

(rsubseq sm > :b <= :y)

(compare 2 2)

(compare "ab" "abc")

(compare ["a" "b" "c"] ["a" "b"])

(compare ["a" 2] ["a" 2 0])

(sort < (repeatedly 10 #(rand-int 100)))

(sort-by first > (map-indexed vector "Clojure"))

((comparator <) 1 4)

((comparator <) 4 1)

((comparator <) 4 4)

(sorted-map-by compare :z 5 :x 9 :y 0 :b 2 :a 3 :c 4)

(sorted-map-by (comp - compare) :z 5 :x 9 :y 0 :b 2 :a 3 :c 4)

(defn magnitude

[x]

(-> x Math/log10 Math/floor))

(magnitude 100)

(magnitude 100000)

(defn compare-magnitude

[a b]

(- (magnitude a) (magnitude b)))

((comparator compare-magnitude) 10 10000)

((comparator compare-magnitude) 100 10)

((comparator compare-magnitude) 10 75)

(sorted-set-by compare-magnitude 10 1000 500)

(conj *1 600)

(disj *1 750)

(contains? *1 1239)

(defn compare-magnitude

[a b]

(let [diff (- (magnitude a) (magnitude b))]

(if (zero? diff)

(compare a b)

diff)))

(sorted-set-by compare-magnitude 10 1000 500)

(conj *1 600)

(disj *1 750)

(sorted-set-by compare-magnitude 10 1000 500 670 1239)

(def ss *1)

(subseq ss > 500)

(subseq ss > 500 <= 1000)

(rsubseq ss > 500 <= 1000)

(defn interpolate

"Takes a collection of points (as [x y] tuples), returning a function

[points]

(let [results (into (sorted-map) (map vec points))]

(fn [x]

(let [[xa ya] (first (rsubseq results <= x))

[xb yb] (first (subseq results > x))]

(if (and xa xb)

(/ (+ (* ya (- xb x)) (* yb (- x xa)))

(- xb xa))

(or ya yb))))))

(def f (interpolate [[0 0] [10 10] [15 5]]))

(map f [2 10 12])

(get [:a :b :c] 2)

(get {:a 5 :b 6} :b)

(get {:a 5 :b 6} :c 7)

(get #{1 2 3} 3)

([:a :b :c] 2)

({:a 5 :b 6} :b)

({:a 5 :b 6} :c 7)

(#{1 2 3} 3)

([:a :b :c] -1)

(get {:a 5 :b 6} :b)

(get {:a 5 :b 6} :c 7)

(get #{:a :b :c} :d)

(:b {:a 5 :b 6})

(:c {:a 5 :b 6} 7)

(:d #{:a :b :c})

(defn get-foo

[map]

(:foo map))

(get-foo nil)

(defn get-bar

[map]

(map :bar))

(get-bar nil)

(map :name [{:age 21 :name "David"}

{:gender :f :name "Suzanne"}

{:name "Sara" :location "NYC"}])

(some #{1 3 7} [0 2 4 5 6])

(some #{1 3 7} [0 2 3 4 5 6])

(filter :age [{:age 21 :name "David"}

{:gender :f :name "Suzanne"}

{:name "Sara" :location "NYC"}])

(filter (comp (partial <= 25) :age) [{:age 21 :name "David"}

{:gender :f :name "Suzanne" :age 20}

{:name "Sara" :location "NYC" :age 34}])

(remove #{5 7} (cons false (range 10)))

(remove #{5 7 false} (cons false (range 10)))

(remove (partial contains? #{5 7 false}) (cons false (range 10)))

'(1 2 3)

'(1 2 (+ 1 2))

(list 1 2 (+ 1 2))

(vector 1 2 3)

(vec (range 5))

(defn euclidian-division

[x y]

[(quot x y) (rem x y)])

(euclidian-division 42 8)

(let [[q r] (euclidian-division 53 7)]

(str "53/7 = " q " * 7 + " r))

(def point-3d [42 26 -7])

(def travel-legs [["LYS" "FRA"] ["FRA" "PHL"] ["PHL" "RDU"]])

#{1 2 3}

#{1 2 3 3}

(hash-set :a :b :c :d)

(set [1 6 1 8 3 7 7])

(apply str (remove (set "aeiouy") "vowels are useless"))

(defn numeric? [s] (every? (set "0123456789") s))

(numeric? "123")

(numeric? "42b")

{:a 5 :b 6}

{:a 5 :a 5}

(hash-map :a 5 :b 6)

(apply hash-map [:a 5 :b 6])

(keys m)

(vals m)

(map key m)

(map val m)

(def playlist

[{:title "Elephant", :artist "The White Stripes", :year 2003}

{:title "Helioself", :artist "Papas Fritas", :year 1997}

{:title "Stories from the City, Stories from the Sea",

:artist "PJ Harvey", :year 2000}

{:title "Buildings and Grounds", :artist "Papas Fritas", :year 2000}

{:title "Zen Rodeo", :artist "Mardi Gras BB", :year 2002}])

(map :title playlist)

(defn summarize [{:keys [title artist year]}]

(str title " / " artist " / " year))

(group-by #(rem % 3) (range 10))

(group-by :artist playlist)

(into {} (for [[k v] (group-by key-fn coll)]

[k (summarize v)]))

(defn reduce-by

[key-fn f init coll]

(reduce (fn [summaries x]

(let [k (key-fn x)]

(assoc summaries k (f (summaries k init) x))))

{} coll))

(def orders

[{:product "Clock", :customer "Wile Coyote", :qty 6, :total 300}

{:product "Dynamite", :customer "Wile Coyote", :qty 20, :total 5000}

{:product "Shotgun", :customer "Elmer Fudd", :qty 2, :total 800}

{:product "Shells", :customer "Elmer Fudd", :qty 4, :total 100}

{:product "Hole", :customer "Wile Coyote", :qty 1, :total 1000}

{:product "Anvil", :customer "Elmer Fudd", :qty 2, :total 300}

{:product "Anvil", :customer "Wile Coyote", :qty 6, :total 900}])

(reduce-by :customer #(+ %1 (:total %2)) 0 orders)

(reduce-by :product #(conj %1 (:customer %2)) #{} orders)

(fn [order]

[(:customer order) (:product order)])

#(vector (:customer %) (:product %))

(fn [{:keys [customer product]}]

[customer product])

(juxt :customer :product)

(reduce-by (juxt :customer :product)

#(+ %1 (:total %2)) 0 orders)

(defn reduce-by-in

[keys-fn f init coll]

(reduce (fn [summaries x]

(let [ks (keys-fn x)]

(assoc-in summaries ks

(f (get-in summaries ks init) x))))

{} coll))

(reduce-by-in (juxt :customer :product)

#(+ %1 (:total %2)) 0 orders)

(def flat-breakup

{["Wile Coyote" "Anvil"] 900,

["Elmer Fudd" "Anvil"] 300,

["Wile Coyote" "Hole"] 1000,

["Elmer Fudd" "Shells"] 100,

["Elmer Fudd" "Shotgun"] 800,

["Wile Coyote" "Dynamite"] 5000,

["Wile Coyote" "Clock"] 300})

(reduce #(apply assoc-in %1 %2) {} flat-breakup)

(+ 1 2)

(def v (vec (range 1e6)))

(count v)