true false 5 14.2 \T "hello" nil

(= 5 5)

(= 5 (+ 2 3))

(= "boot" (str "bo" "ot"))

(= nil nil)

(let [a 5]

(do-something-with-a-number a)

(= a 5))

public class StatefulInteger extends Number {

private int state;

public StatefulInteger (int initialState) {

this.state = initialState;

}

public void setInt (int newState) {

this.state = newState;

}

public int intValue () {

return state;

}

public int hashCode () {

return state;

}

public boolean equals (Object obj) {

return obj instanceof StatefulInteger &&

state == ((StatefulInteger)obj).state;

}

// remaining xxxValue() methods from java.lang.Number...

}

(def five (StatefulInteger. 5))

(def six (StatefulInteger. 6))

(.intValue five)

(= five six)

(.setInt five 6)

(= five six)

(defn print-number

[n]

(println (.intValue n))

(.setInt n 42))

(print-number six)

(= five six)

(= five (StatefulInteger. 42))

(def h {[1 2] 3})

(h [1 2])

(conj (first (keys h)) 3)

(h [1 2])

h

(defn call-twice [f x]

(f x)

(f x))

(call-twice println 123)

(max 5 6)

(require 'clojure.string)

(clojure.string/lower-case "Clojure")

(map clojure.string/lower-case ["Java" "Imperative" "Weeping"

"Clojure" "Learning" "Peace"])

(map * [1 2 3 4] [5 6 7 8])

(reduce max [0 -3 10 48])

(max 0 -3)

(max 0 10)

(max 10 48)

(max (max (max 0 -3) 10) 48)

(reduce + 50 [1 2 3 4])

(reduce

(fn [m v]

(assoc m v (* v v)))

{}

[1 2 3 4])

(reduce

#(assoc % %2 (* %2 %2))

{}

[1 2 3 4])

((complement pos?) 5)

((complement string?) "hello")

((complement string?) :hello)

(take 10 (repeatedly #(rand-int 10)))

(take 3 (repeatedly (fn []

(Thread/sleep 1000)

(System/currentTimeMillis))))

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

(def args [2 -2 10])

(apply * 0.5 3 args)

(def only-strings (partial filter string?))

(only-strings ["a" 5 "b" 6])

(def database-lookup (partial get-data "jdbc:mysql://..."))

(#(filter string? %) ["a" 5 "b" 6])

(#(filter % ["a" 5 "b" 6]) string?)

(#(filter % ["a" 5 "b" 6]) number?)

(#(map *) [1 2 3] [4 5 6] [7 8 9])

(#(map * % %2 %3) [1 2 3] [4 5 6] [7 8 9])

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

(#(apply map * %&) [1 2 3] [4 5 6] [7 8 9])

(#(apply map * %&) [1 2 3])

((partial map *) [1 2 3] [4 5 6] [7 8 9])

(defn negated-sum-str

[& numbers]

(str (- (apply + numbers))))

(negated-sum-str 10 12 3.4)

(def negated-sum-str (comp str - +))

(negated-sum-str 10 12 3.4)

((comp + - str) 5 10)

(require '[clojure.string :as str])

(def camel->keyword (comp keyword

str/join

(partial interpose \-)

(partial map str/lower-case)

#(str/split % #"(?<=[a-z])(?=[A-Z])")))

(camel->keyword "CamelCase")

(camel->keyword "lowerCamelCase")

(defn camel->keyword

[s]

(->> (str/split s #"(?<=[a-z])(?=[A-Z])")

(map str/lower-case)

(interpose \-)

str/join

keyword))

(def camel-pairs->map (comp (partial apply hash-map)

(partial map-indexed (fn [i x]

(if (odd? i)

x

(camel->keyword x))))))

(camel-pairs->map ["CamelCase" 5 "lowerCamelCase" 3])

(defn adder

[n]

(fn [x] (+ n x)))

((adder 5) 18)

(defn doubler

[f]

(fn [& args]

(* 2 (apply f args))))

(def double-+ (doubler +))

(double-+ 1 2 3)

(defn print-logger

[writer]

#(binding [*out* writer]

(println %)))

(def *out*-logger (print-logger *out*))

(*out*-logger "hello")

(def writer (java.io.StringWriter.))

(def retained-logger (print-logger writer))

(retained-logger "hello")

(str writer)

(require 'clojure.java.io)

(defn file-logger

[file]

#(with-open [f (clojure.java.io/writer file :append true)]

((print-logger f) %)))

(def log->file (file-logger "messages.log"))

(log->file "hello")

% more messages.log

hello

(defn multi-logger

[& logger-fns]

#(doseq [f logger-fns]

(f %)))

(def log (multi-logger

(print-logger *out*)

(file-logger "messages.log")))

(log "hello again")

% more messages.log

hello

hello again

(defn timestamped-logger

[logger]

#(logger (format "[%1$tY-%1$tm-%1$te %1$tH:%1$tM:%1$tS] %2$s" (java.util.Date.) %)))

(def log-timestamped (timestamped-logger

(multi-logger

(print-logger *out*)

(file-logger "messages.log"))))

(log-timestamped "goodbye, now")

% more messages.log

hello

hello again

[2011-11-30 08:54:00] goodbye, now

(defn perform-bank-transfer!

[from-account to-account amount]

...)

(defn authorize-medical-treatment!

[patient-id treatment-id]

...)

(defn launch-missiles!

[munition-type target-coordinates]

...)

(require 'clojure.xml)

(defn twitter-followers

[username]

(->> (str "https://api.twitter.com/1/users/show.xml?screen_name=" username)

clojure.xml/parse

:content

(filter (comp #{:followers_count} :tag))

first

:content

first

Integer/parseInt))

(twitter-followers "ClojureBook")

(twitter-followers "ClojureBook")

(+ 1 2) (- 10 7) (count [-1 0 1])

(defn prime?

[n]

(cond

(== 1 n) false

(== 2 n) true

(even? n) false

:else (->> (range 3 (inc (Math/sqrt n)) 2)

(filter #(zero? (rem n %)))

empty?)))

(time (prime? 1125899906842679))

(let [m-prime? (memoize prime?)]

(time (m-prime? 1125899906842679))

(time (m-prime? 1125899906842679)))

(repeatedly 10 (partial rand-int 10))

(repeatedly 10 (partial (memoize rand-int) 10))