1 (if (< (rand-int 10) 5)
2   "Smaller than 5"
3   "Greater or equal than 5")

1 (let [x (+ 1 2 3)
2       y (+ 4 5 6)
3       z (+ x y)]
4   z) ;;=> 21

1 (inc 1) ;;=> 2

1 inc(1) // 2

1 (def my-fun (fn [x]
2               (+ x 2)))
3 
4 ;; same as:
5 (defn my-fun [x]
6   (+ x 2))

1 1     ;; integer literal
2 "foo" ;; string literal
3 'foo  ;; quoted symbol
4 foo   ;; symbol (will evaluate to value bound to foo)
5 :foo  ;; keyword, more or less a constant, often used as key in hashmap
6 {:a 1, :b 2} ;; map literal

1 (def v1 (vector 1 2 3 4))
2 (def v2 [1 2 3 4])
3 (= v1 v2) ;; true
4 (get v1 0) ;; 1
5 (get v1 3) ;; 4
6 (get v1 4) ;; nil
7 (v1 0) ;; 1
8 (v1 3) ;; 4
9 (conj v1 5) ;; [1 2 3 4 5]

1 (def m1 {:a 1 :b 2})
2 (get m1 :a) ;; 1
3 (get m1 :b) ;; 2
4 (m1 :a) ;; 1
5 (:a m1) ;; 1
6 (:c m1) ;; nil
7 (assoc m1 :c 3) ;; {:c 3, :b 2, :a 1}

1 (def expr (list 'println 1 2 3)) ;; (println 1 2 3), unevaluated
2 (eval expr) ;; prints 1 2 3, normally we don't do this
3 (conj (list 1 2 3) 4) ;; (4 1 2 3)

1 (def s1 #{1 2 3})
2 (contains? s1 1) ;;=> true
3 (contains? s1 4) ;;=> false
4 (conj s1 4) ;;=> #{1 2 3 4}
5 (disj s1 3) ;;=> #{1 2}

1 (def v1 [1 2 3 4])
2 (first v1) ;; 1
3 (rest v1) ;; (2 3 4)
4 (map inc v1) ;; (2 3 4 5)
5 (filter odd? v1) ;; (1 3)
6 (remove odd? v1) ;; (2 4)

 1 (def game-state (atom {:score 0}))
 2 
 3 (defn increase-score [old-state points]
 4 (update-in old-state [:score] + points))
 5 
 6 ;; test:
 7 (increase-score {:score 40} 20) ;;=> {:score 60}
 8 
 9 (defn score! []
10   (swap! game-state increase-score 20))
11 
12 @game-state ;;=> {:score 0}
13 (score!)
14 @game-state ;;=> {:score 20}
15 (score!)
16 @game-state ;;=> {:score 40}

1 (defn handler [req]
2   {:status 200
3    :body "{:a 1, :b 2}"
4    :headers {"Content-Type" "application/edn"})
5 
6 (defn run-server []
7   (run-jetty #'handler {:port 8080}))

 1 (defroutes main-routes
 2   (GET "/" [] (index-page))
 3   (GET "/animals/:id" [id]
 4     (find-animal id))
 5   (route/resources "/")
 6   (route/not-found "Page not found"))
 7 
 8 (def app
 9   (-> (handler/site main-routes)
10     (wrap-base-url)))

1 (defresource hello-world
2   :available-media-types ["text/plain"]
3   :handle-ok "Hello, world!")

1 -------------------------------------------
2 | entity | attribute | value              |
3 -------------------------------------------
4 | 42     | :email     | jdoe@example.com  |
5 | 43     | :email     | jane@example.com  |
6 | 42     | :orders    | 107               |
7 | 42     | :orders    | 141               |
8 -------------------------------------------

1 [?customer :email ?email]

1 [42 :email ?email]

1 -------------------------------------------
2 | entity | attribute | value              |
3 -------------------------------------------
4 | 42     | :email     | jdoe@example.com  |
5 | 43     | :email     | jane@example.com  |
6 | 42     | :orders    | 107               |
7 | 42     | :orders    | 141               |
8 -------------------------------------------

1 [42 ?attribute]

1 [42 ?attribute ?value]

1 [:find ?customer
2  :where [?customer :email]]

1 [:find ?customer
2  :where [?customer :email]
3         [?customer :orders]]

1 (q '[:find ?customer :in $ :where [?customer :id] [?customer :orders]]
2    db)

1 (q '[:find ?customer :in $ ?email :where [?customer :email ?email]]
2     db "jdoe@example.com")

1 [(< 50.0 ?price)]

1 [:find ?item
2  :where [?item :item/price ?price]
3         [(< 50.0 ?price)]]

1 [:find ?a (min ?b) (max ?b) ?c (sample 12 ?d) :where ...]

1 [(shipping ?zip ?weight) ?cost]

1 [:find ?customer ?product
2  :where [?customer :shipAddress ?address]
3         [?address :zip ?zip]
4         [?product :product/weight ?weight]
5         [?product :product/price ?price]
6         [(Shipping/estimate ?zip ?weight) ?shipCost]
7         [(<= ?price ?shipCost)]]