Code from Joy of Clojure, chapter 3

joy-of-clojure-ch3.clj

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 3.2 Nil pun with care

(defn print-seq [s]
  (when (seq s)
     (prn (first s))
     (recur (rest s))))
;; #'user/print-seq

(print-seq [1 2])
;; 1
;; 2
;; nil

(doseq [n (range 5)]
  (println  n)) 
;; 0
;; 1
;; 2
;; 3
;; 4
;; nil


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3.3 Destructuring

(def guys-whole-name ["Guy" "Lewis" "Steel"]) 
;; #'user/guys-whole-name

(str (nth guys-whole-name 2) ", "
     (nth guys-whole-name 0) " "
     (nth guys-whole-name 1))
;;"Steel, Guy Lewis"

(let [[fname mname lname] guys-whole-name]
  (str lname ", " fname " " mname))
;; "Steel, Guy Lewis"

(let [[fname mname lname & namedata] guys-whole-name]
   (str lname ", " fname " " mname))
;; "Steel, Guy Lewis"

(let [[fname mname lname :as namedata] guys-whole-name]
   (str lname ", " fname " " mname " (from " namedata ")"))
;; "Steel, Guy Lewis (from [\"Guy\" \"Lewis\" \"Steel\"])"

(let [[a b c & more] (range 10)]
   (println "a b c are: " a b c))
;; a b c are:  0 1 2

(let [[a b c & more] (range 10)]
   (println "a b c are: " a b c)
   (println "more is: " more))
;; a b c are:  0 1 2
;; more is:  (3 4 5 6 7 8 9)
;; nil

(let [range-vec (vec (range 10))
      [a b c & more :as all] range-vec]
    (println "a b c are:" a b c)
    (println "more is:" more))
;; a b c are: 0 1 2
;; more is: (3 4 5 6 7 8 9)
;; nil

(let [range-vec (vec (range 10))
            [a b c & more :as all] range-vec]
        (println "a b c are:" a b c)
        (println "more is:" more)
        (println "all is:" all))
;; a b c are: 0 1 2
;; more is: (3 4 5 6 7 8 9)
;; all is: [0 1 2 3 4 5 6 7 8 9]
;; nil

(def guys-name-map
  {:fname "Guy" :mname "Lewis" :lname "Steele"})
;; #'user/guys-name-map

(let [{fname :fname
             mname :mname
             lname :lname} guys-name-map]
        (str lname ", " fname " " mname))
;; "Steele, Guy Lewis"

(let [{:keys [fname mname lname]} guys-name-map]
        (str lname ", " fname " " mname))
;; "Steele, Guy Lewis"

(let [{fname :fname :as whole-name} guys-name-map]
        whole-name)
;; {:fname "Guy", :mname "Lewis", :lname "Steele"}

(let [{:keys [title fname mname lname] :or {title "Mr."}} guys-name-map]
        (println title fname mname lname))
;; Mr. Guy Lewis Steele
;; nil

(let [{first-thing 0 last-thing 3} [1 2 3 4]]
  [first-thing last-thing])
;; [1 4]

(defn print-last-name [{:keys [lname]}]
   (println lname))
;; #'user/print-last-name

(print-last-name guys-name-map)
;; Steele
;; nil


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3.4 Using the REPL to experiment

(find-doc "xor")
;; -------------------------
;; clojure.core/bit-xor
;; ([x y])
;;   Bitwise exclusive or
;; nil

(for [x (range 2) y (range 2)] [x y (bit-xor x y)])
;; ([0 0 0] [0 1 1] [1 0 1] [1 1 0])

(defn xors [max-x max-y]
   (for [x (range max-x) y (range max-y)]
     [x y (bit-xor x y)]))
;; #'user/xors

(def frame (java.awt.Frame.))
;; #'user/frame

(for [method (seq (.getMethods java.awt.Frame))
      :let [method-name (.getName method)]
      :when (re-find #"Vis" method-name)]
  method-name)
;; ("setVisible" "isVisible")


(for [method (seq (.getMethods java.awt.Frame))
      :let [method-name (.getName method)]
      :when (re-find #"Vis" method-name)]
   method-name)
;; ("setVisible" "isVisible")

(for [n (range 5)
            :let [m n]
            :when (= 0 (rem n 2))]
        m)
;; (0 2 4)

(.isVisible frame)
;; false

(.setVisible frame true)
;; nil

(.setSize frame (java.awt.Dimension. 200 200))
;; nil

(javadoc frame)
;; "http://java.sun.com/javase/6/docs/api/java/awt/Frame.html"

(def gfx (.getGraphics frame))
;; #'user/gfx

(.fillRect gfx 100 100 50 75)
;; nil

(.setColor gfx (java.awt.Color. 255 128 0))
;; nil

(.fillRect gfx 100 150 75 50)
;; nil

(.setColor gfx (java.awt.Color. 255 128 0))
;; nil

(.fillRect gfx 100 100 50 75)
;; nil

(doseq [[x y xor] (xors 200 200)]
    (.setColor gfx (java.awt.Color. xor xor xor))
    (.fillRect gfx x y 1 1))
;; nil

(doseq [[x y xor] (xors 500 500)]
   (.setColor gfx (java.awt.Color. xor xor xor))
   (.fillRect gfx x y 1 1))
;; Evaluation aborted.

(.printStackTrace *e)
;; java.lang.IllegalArgumentException: Color parameter outside of expected range: Red Green Blue (NO_SOURCE_FILE:0)
;; 	at clojure.lang.Compiler.eval(Compiler.java:5440)
;; 	at clojure.lang.Compiler.eval(Compiler.java:5391)
;; 	at clojure.core$eval.invoke(core.clj:2382)
;; 	at swank.commands.basic$eval_region.invoke(basic.clj:47)
;; 	at swank.commands.basic$eval_region.invoke(basic.clj:37)
;; 	at swank.commands.basic$eval797$listener_eval__798.invoke(basic.clj:71)
;; 	at clojure.lang.Var.invoke(Var.java:365)
;; 	at user$eval3947.invoke(NO_SOURCE_FILE)
;;      etc...
;; Caused by: java.lang.IllegalArgumentException: Color parameter outside of expected range: Red Green Blue
;; 	at java.awt.Color.testColorValueRange(Unknown Source)
;; 	at java.awt.Color.<init>(Unknown Source)
;; 	at java.awt.Color.<init>(Unknown Source)
;; 	at sun.reflect.GeneratedConstructorAccessor1.newInstance(Unknown Source)
;; 	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
;; 	at java.lang.reflect.Constructor.newInstance(Unknown Source)
;; 	at clojure.lang.Reflector.invokeConstructor(Reflector.java:160)
;; 	at user$eval3953.invoke(NO_SOURCE_FILE:1)
;;	at clojure.lang.Compiler.eval(Compiler.java:5424)
;; 	... 26 more
;; nil

(defn xors [xs ys]
  (for [x (range xs) y (range ys)]
    [x y (rem (bit-xor x y) 256)]))
;; #'user/xors

(defn clear [g] (.clearRect g 0 0 200 200))
;; #'user/clear

(doseq [[x y xor] (xors 500 500)]
   (.setColor gfx (java.awt.Color. xor xor xor))
   (.fillRect gfx x y 1 1))
;; nil

(defn f-values [f xs ys]
   (for [x (range xs) y (range ys)]
     [x y (rem (f x y) 256)]))
;; #'user/f-values

user> (defn draw-values [f xs ys]
        (clear gfx)
        (.setSize frame (java.awt.Dimension. xs ys))
        (doseq [[x y v] (f-values f xs ys)]
          (.setColor gfx (java.awt.Color. v v v))
          (.fillRect gfx x y 1 1)))
;; #'user/draw-values

(draw-values bit-and 256 256)
;; nil

(draw-values + 256 256)
;; nil

(draw-values * 256 256)
;; nil