;;;; Snippet #1 (def standard-gruss "Hallo") (defn gruesse-mich [mein-name] (println standard-gruss mein-name)) ;;;; ;;;; Snippet #2 user> (def +erlaubt-*?23 ) #'user/+erlaubt-*?23 user> (def 111verboten) java.lang.NumberFormatException: Invalid number: 111verboten java.lang.Exception: Unmatched delimiter: ) user> (def verb%ten) java.lang.Exception: Unable to resolve symbol: %ten in this context user> (def _erlaubt_) #'user/_erlaubt_ ;;;; ;;;; Snippet #3 user> (def wahl {:spd {:stimmen 10} :cdu {:stimmen 10} :fdp {:stimmen 10} :gruen {:stimmen 10} :piraten {:stimmen 10}}) #'user/wahl user> (update-in wahl [:piraten :stimmen] inc) {:spd {:stimmen 10}, :cdu {:stimmen 10}, :fdp {:stimmen 10}, :gruen {:stimmen 10}, :piraten {:stimmen 11}} user> (update-in {:a 1 :b [1 2 3]} [:b] conj 4) {:a 1, :b [1 2 3 4]} ;;;; ;;;; Snippet #4 user> (defstruct kinofilm :titel :regisseur) #'user/kinofilm user> (type (struct-map kinofilm :titel "Der Herr der Ringe I" :regisseur "Peter Jackson")) clojure.lang.PersistentStructMap user> (struct-map kinofilm :titel "Der Herr der Ringe I" :regisseur "Peter Jackson") {:titel "Der Herr der Ringe", :regisseur "Peter Jackson"} user> (struct-map kinofilm :titel "Der Herr der Ringe I" :regisseur "Peter Jackson" :jahr 2001) {:titel "Der Herr der Ringe I", :regisseur "Peter Jackson", :jahr 2001} user> (struct-map kinofilm :titel "Der Herr der Ringe I" :jahr 2001) {:titel "Der Herr der Ringe I", :regisseur nil, :jahr 2001} ;;;; ;;;; Snippet #5 user> (def kinofilm-titel (accessor kinofilm :titel)) #'user/kinofilm-titel user> (kinofilm-titel (struct-map kinofilm :titel "Der Herr der Ringe I" :jahr 2001)) "Der Herr der Ringe I" ;;;; ;;;; Snippet #6 user> (dotimes [i 2] (intern *ns* (symbol (str "prefix" (inc i))) (str "Original " (inc i)))) nil user> prefix1 "Original 1" user> prefix2 "Original 2" ;;;; ;;;; Snippet #7 (defn fn-mit-bindings [arg1 arg2] (println "Lokales Binding arg1 " arg1) (println "Lokales Binding arg2 " arg2)) user> (fn-mit-bindings 1 2) Lokales Binding arg1 1 Lokales Binding arg2 2 nil user> (fn-mit-bindings "Eins" "Zwei") Lokales Binding arg1 Eins Lokales Binding arg2 Zwei nil ;;;; ;;;; Snippet #8 (defn quadrat-mit-ausgabe [x] (let [resultat (* x x )] (println "Quadrat von" x "ist" resultat) resultat)) user> (quadrat-mit-ausgabe 2) Quadrat von 2 ist 4 4 user> (quadrat-mit-ausgabe 100) Quadrat von 100 ist 10000 10000 user> resultat java.lang.Exception: Unable to resolve symbol: resultat in this context ;;;; ;;;; Snippet #9 (defn quad-sum [x y] (let [sum (+ x x) qua (* sum sum)] (println "Summe ist" sum) (println "Quadrat davon ist" qua) qua)) user> (quad-sum 2 3) Summe ist 4 Quadrat davon ist 16 16 ;;;; ;;;; Snippet #10 (def *wert* "Root-Binding") (defn fn1 [] (println "Wert in FN1:" *wert*)) (defn fn2 [] (println "Am Anfang von FN2:" *wert*) (let [*wert* "LET in FN2"] (println "Im LET von FN2:" *wert*) (fn1))) (defn fn3 [] (println "Am Anfang von FN3:" *wert*) (binding [*wert* "GEBUNDEN FN3"] (println "Im BINDING von FN3:" *wert*) (fn1))) user> (fn1) Wert in FN1: Root-Binding nil user> (fn2) Am Anfang von FN2: Root-Binding Im LET von FN2: LET in FN2 Wert in FN1: Root-Binding nil user> (fn3) Am Anfang von FN3: Root-Binding Im BINDING von FN3: GEBUNDEN FN3 Wert in FN1: GEBUNDEN FN3 nil ;;;; ;;;; Snippet #11 (defn fn4 [] (println "Am Anfang von FN4:" *wert*) (let [*wert* "Lokal in FN4"] (println "Im LET von FN4:" *wert*) (fn1) (binding [*wert* "GEBUNDEN in FN4"] (println "Huch! Im BINDING von FN4:" *wert*) (fn1)))) user> (fn4) Am Anfang von FN4: Root-Binding Im LET von FN4: Lokal in FN4 Wert in FN1: Root-Binding Huch! Im BINDING von FN4: Lokal in FN4 Wert in FN1: GEBUNDEN in FN4 nil ;;;; ;;;; Snippet #12 (defn thread1 [] (println "Thread1-Root:" *wert*) (binding [*wert* "Lokal-In-Thread1"] (println "Thread1 binding vor sleep:" *wert*) (flush) (Thread/sleep 2000) (println "Thread1 binding nach sleep:" *wert*))) (defn thread2 [] (Thread/sleep 1000) (println "Thread2-Root:" *wert*) (binding [*wert* "Lokal-In-Thread2"] (println "Thread2 binding: " *wert*))) user> (do (.start (Thread. thread1)) (.start (Thread. thread2))) Thread1-Root: Root-Binding Thread1 binding vor sleep: Lokal-In-Thread1 Thread2-Root: Root-Binding Thread2 binding: Lokal-In-Thread2 Thread1 binding nach sleep: Lokal-In-Thread1 nil ;;;; ;;;; Snippet #13 (def *die-var* 23) (defn println-die-var [thrnam] (println thrnam *die-var*)) user> (let [*die-var* 42] (println-die-var "REPL-Thread") (.start (Thread. #(println-die-var "LET-Thread"))) (Thread/sleep 10) (binding [*die-var* 5] (println-die-var "REPL-Thread(wieder)") (.start (Thread. #(println-die-var "BINDING-Thread"))) (Thread/sleep 10))) REPL-Thread 23 LET-Thread 23 REPL-Thread(wieder) 5 BINDING-Thread 23 nil ;;;; ;;;; Snippet #14 (defn schluessel [haus auto & {:keys [garage rad]}] (list haus auto garage rad)) user> (schluessel "nr1" "nr2") ("nr1" "nr2" nil nil) user> (schluessel "nr1" "nr2" :garage "der rote") ("nr1" "nr2" "der rote" nil) ;;;; ;;;; Snippet #15 user> (schluessel :garage "der rote" "nr1" "nr2" ) (:garage "der rote" nil nil) ;;;; ;;;; Snippet #16 (defn nur-schluessel [& {:keys [haus auto garage rad]}] (list haus auto garage rad)) user> (nur-schluessel :haus "No. 9" :rad "klein" :auto "funk") ("No. 9" "funk" nil "klein") user> (nur-schluessel "ja, wo ist er denn?") java.lang.IllegalArgumentException: No value supplied for key: ja, wo ist er denn? ;;;; ;;;; Snippet #17 user> (let [f-strings [(format "Die wilde %d" 13) (format "Die %s 13" "wilde") (format "König Alfons der %s vor %d-te" 1/4 12)]] (doseq [fs f-strings] (println fs))) Die wilde 13 Die wilde 13 König Alfons der 1/4 vor 12-te nil ;;;; ;;;; Snippet #18 (defn mind-zehn [x] (if (< x 10) ;; then: zu wenig (do (println "Zu wenig, bekommst 10") 10) ;; else, das geht so x)) user> (mind-zehn 5) Zu wenig, bekommst 10 10 user> (mind-zehn 15) 15 ;;;; ;;;; Snippet #19 ;; Namensliste keineswegs vollständig :) (def irc-leute #{"chouser" "hiredman" "rhickey" "lpetit"}) (defn pruefe-nachricht [msg] (when (irc-leute (:sender msg)) (println "Nachricht evtl. wichtig?"))) user> (pruefe-nachricht {:sender "ska2342" :text "Hi, I have a question"}) nil user> (pruefe-nachricht {:sender "rhickey" :text "New Clojure release!"}) Nachricht evtl. wichtig? nil ;;;; ;;;; Snippet #20 (defn zahl [x] (if (and (string? x) (re-find #"^[0-9]+$" x)) (Integer/parseInt x) x)) user> (zahl 3) 3 user> (zahl "92") 92 ;;;; ;;;; Snippet #21 (defn vollzugriff? [f] (let [ff (if (instance? java.io.File f) f (java.io.File. f))] (and (.canRead ff) (.canWrite ff)))) user> (vollzugriff? (str (System/getenv "HOME") (java.io.File/separator) ".bashrc")) true user> (vollzugriff? (java.io.File. "/etc/hosts")) false ;;;; ;;;; Snippet #22 (defn wer-wars? [anlass] (if-not (= anlass "steinigung") "Sie war's" "Er war's")) user> (wer-wars? "essen") "Sie war's" user> (wer-wars? "steinigung") "Er war's" ;;;; ;;;; Snippet #23 (defn denk-an-creme [himmel] (when-not (= himmel "wolkig") "Denk an die Sonnencreme")) user> (denk-an-creme "blau") "Denk an die Sonnencreme" ;;;; ;;;; Snippet #24 (defn welche-schuhe [temp niederschlag] (cond (and (not niederschlag) (> temp 30)) "Flip-Flops" (and (not niederschlag) (> temp 20)) "Sandalen" (< temp 5) "Stiefel" (not niederschlag) "Turnschuhe" :else "Halbschuhe")) user> (welche-schuhe 30 false) "Sandalen" user> (welche-schuhe 30 true) "Halbschuhe" user> (welche-schuhe 15 false) "Turnschuhe" user> (welche-schuhe 1 true) "Stiefel" ;;;; ;;;; Snippet #25 (defn dc [x] (condp = (class x) String (.toLowerCase x) Integer (str (Character/toLowerCase (char x))))) user> (dc "HALLO") "hallo" user> (char 89) \Y user> (dc 89) "y" user> (dc ["A" "B" "C"]) java.lang.IllegalArgumentException: No matching clause: class clojure.lang.PersistentVector ;;;; ;;;; Snippet #26 (defn welches-pred [ding] (condp apply [ding] integer? "Ist ein Integer" keyword? "Ist ein Keyword" pos? "Zahl größer 0")) user> (welches-pred 1) "Ist ein Integer" user> (welches-pred :hallo) "Ist ein Keyword" user> (welches-pred 4.5) "Zahl größer 0" ;;;; ;;;; Snippet #27 (defn t [x] (condp < x 100 :>> #(println "< 100" x %) 10 :>> #(println "< 10" x %) 1 :>> #(println "< 1" x %))) user> (t 5) < 1 5 true nil user> (t 50) < 10 50 true nil user> (t 500) < 100 500 true nil ;;;; ;;;; Snippet #28 (def media-db [{:type :cd :artist "Ozric Tentacles" :title "Become the Other"} {:type :ogg :artist "Phish" :title "Lawn Boy"}]) (defn medien-ort [m] (case (:type m) :cd "Schrank" :ogg "Computer")) user> (map medien-ort media-db) ("Schrank" "Computer") ;;;; ;;;; Snippet #29 (defn viertes-hoch-fuenftes [col] (when-let [viert (nth col 4 nil)] (when-let [fuenft (nth col 5 nil)] (Math/pow viert fuenft)))) user> (nth [1 2 3] 99 "Bei 99 ist nix") "Bei 99 ist nix" user> (viertes-hoch-fuenftes [1 2 3]) nil user> (viertes-hoch-fuenftes [0 1 2 3 2 3]) 8.0 user> (viertes-hoch-fuenftes [0 1 2 3 4 2]) 16.0 ;;;; ;;;; Snippet #30 user> (try (with-open [stream (java.io.BufferedReader. (java.io.FileReader. "/home/clj/.emacs"))] (println "Habe .emacs gefunden") (println "Erste Zeile: " (.readLine stream))) (catch java.io.IOException e (println "Problem beim Oeffnen von .emacs\n" e)) (catch Exception e (println "Unerwartete Exception: " e)) (finally (println "\nBin mit der Pruefung durch"))) Problem beim Oeffnen von .emacs # Bin mit der Pruefung durch nil ;;;; ;;;; Snippet #31 (defn eins-zwei-oder-drei ([eins] (println "Eins,")) ([eins zwei] (println "Zwei,")) ([eins zwei drei] (println "Oder drei.") (println "Du musst dich entscheiden," "drei Felder sind frei."))) user> (eins-zwei-oder-drei 1) Eins, nil user> (eins-zwei-oder-drei 1 1) Zwei, nil user> (eins-zwei-oder-drei 1 1 1) Oder drei. Du musst dich entscheiden, drei Felder sind frei. nil ;;;; ;;;; Snippet #32 (defn simpel-plus "Addiere zwei Zahlen, wenn kein Argument da ist, liefer 0." ([] 0) ([x] x) ([x y] (+ x y))) user> (simpel-plus) 0 user> (simpel-plus 1) 1 user> (simpel-plus 1 2) 3 ;;;; ;;;; Snippet #33 user> (reduce (fn [x y] (let [s (str x " " y)] (println s) s)) '("ich" "und" "du" "muellers" "esel" "meiers" "kuh")) ich und ich und du ich und du muellers ich und du muellers esel ich und du muellers esel meiers ich und du muellers esel meiers kuh "ich und du muellers esel meiers kuh" ;;;; ;;;; Snippet #34 (defn fn11 [] (println "Liefer 11 zurück") 11) (defn fn22 [] (println "Liefer 22 zurück") 22) user> (+ (fn11) (fn22)) Liefer 11 zurück Liefer 22 zurück 33 ;;;; ;;;; Snippet #35 (defn fn33 [] (println "Liefer 33 zurück") 33) (defn fn44 [] (println "Liefer 44 zurück") 44) user> (+ (+ (fn11) (fn22)) (+ (fn33) (fn44))) Liefer 11 zurück Liefer 22 zurück Liefer 33 zurück Liefer 44 zurück 110 ;;;; ;;;; Snippet #36 (def ich-halte-eine-fn (fn [arg] (println "Mein Argument war" arg))) user> (ich-halte-eine-fn "Hallo") Mein Argument war Hallo nil ;;;; ;;;; Snippet #37 ;; Klammern beachten user> ((fn [arg] (println "Mein Argument war" arg)) "Hallo") Mein Argument war Hallo nil user> (defn auch-nur-mal [] *) #'user/auch-nur-mal user> (fn? (auch-nur-mal)) true user> ((auch-nur-mal) 5 10) 50 ;;;; ;;;; Snippet #38 (defmacro plus-a-b [a b] (list '+ a b)) user> (plus-a-b 2 3) 5 ;;;; ;;;; Snippet #39 (defn liefer-2 [] (println "Ich gebe 2 zurück") 2) (defmacro plus-a-b-print [a b] (println "Im Makro") (list '+ a b)) user> (plus-a-b-print (liefer-2) 5) Im Makro Ich gebe 2 zurück 7 (defn plus-a-b-fn [a b] (println "In Funktion") (+ a b)) user> (plus-a-b-fn (liefer-2) 5) Ich gebe 2 zurück In Funktion 7 ;;;; ;;;; Snippet #40 user> (map inc [1 2 3]) (2 3 4) (defmacro vmap [coll f] "Wie map nur verkehrt." `(map ~f ~coll)) user> (vmap [1 2 3] inc) (2 3 4) user> (macroexpand-1 '(vmap [1 2 3] inc)) (clojure.core/map inc [1 2 3]) user> (vmap [1 2 3] (fn [x] (if (odd? x) (inc x) x))) (2 2 4) user> (vmap ["Watermelon" "In" "Easter" "Hay"] (fn [s] (.length s))) (10 2 6 3) ;;;; ;;;; Snippet #41 (defmacro emap [v coll & body] "Wie vmap nur ohne Funktion." `(map (fn [~v] ~@body) ~coll)) user> (emap x [1 2 3] (if (odd? x) (inc x) x)) (2 2 4) user> (macroexpand-1 '(emap x [1 2 3] (if (odd? x) (inc x) x))) (clojure.core/map (clojure.core/fn [x] (if (odd? x) (inc x) x)) [1 2 3]) ;;;; ;;;; Snippet #42 (defn nimm-bratwurst [] (throw (Exception. "Aua, heiß!"))) user> (nimm-bratwurst) java.lang.Exception: Aua, heiß! (defmacro mit-zange [& exprs] (let [e (gensym)] `(try ~@exprs (catch Exception ~e nil)))) user> (mit-zange (nimm-bratwurst)) nil ;;;; ;;;; Snippet #43 UNA:+.? ' UNB+UNOC:3+Gast+Wirt+100325:2349+1++123' UNH+1+ORDERS:D:96A:UN' BGM+220+108' DTM+4:20060620:102' NAD+BY+++Stefan+Tisch 3++++xx' LIN+1++Ein Helles:SA' QTY+1:1' UNS+S' CNT+2:1' UNT+9+1' UNZ+1+123' ;;;; ;;;; Snippet #44 (def seg-trenn \') (def grup-trenn \:) (def datelm-trenn \+) (def escape-zeich \?) ;;;; ;;;; Snippet #45 (defn lies-neun [rdr] (apply str (take 9 (repeatedly #(char (.read rdr)))))) user> (use '(clojure.java [io :only (reader)])) nil user> (with-open [rdr (reader "una.edi")] (lies-neun rdr)) "UNA:+.? /" user> (with-open [rdr (reader "test.edi")] (lies-neun rdr)) "UNB+UNOC:" ;;;; ;;;; Snippet #46 (defmacro with-edifact-file [rdr file & body] `(let [~rdr (reader ~file) kopf# (lies-neun ~rdr)] (if (.startsWith kopf# "UNA") (binding [seg-trenn (nth kopf# 8) grup-trenn (nth kopf# 3) datelm-trenn (nth kopf# 4) escape-zeich (nth kopf# 6)] ~@body) (do ~@body)))) ;;;; ;;;; Snippet #47 user> (with-edifact-file strm "una.edi" seg-trenn) \/ user> (with-edifact-file strm "test.edi" seg-trenn) \' ;;;; ;;;; Snippet #48 (defn quersumme [zahl] (loop [x zahl summe 0] (if (< x 9) (+ summe x) (recur (int (/ x 10)) (+ summe (mod x 10)))))) user> (quersumme 3) 3 user> (quersumme 34) 7 user> (quersumme 345) 12 ;;;; ;;;; Snippet #49 (defmulti quersumme type) ;;;; ;;;; Snippet #50 (defmethod quersumme Integer [zahl] (loop [x zahl summe 0] (if (< x 9) (+ summe x) (recur (int (/ x 10)) (+ summe (mod x 10)))))) user> (quersumme 345) 12 user> (quersumme "2147483647") 46 ;;;; ;;;; Snippet #51 (defmethod quersumme String [zahl-s] (try (let [zahl (Integer/parseInt zahl-s)] (quersumme zahl)) (catch NumberFormatException e (throw (IllegalArgumentException. "String enthaelt kein Int"))))) user> (quersumme "22") 4 user> (quersumme "22.5") java.lang.IllegalArgumentException: String enthaelt kein Int ;;;; ;;;; Snippet #52 (defmethod quersumme Number [zahl] (throw (IllegalArgumentException. "Argument ist keine ganze Zahl"))) user> (quersumme 44.5) java.lang.IllegalArgumentException: Argument ist keine ganze Zahl ;;;; ;;;; Snippet #53 (def my-text " 1. Regexps haben eine Read-Syntax 2. Clojure hat einige Match-Funktionen 3. Idiomatisch ist eine Lazy Sequence") (def my-matcher (re-matcher #"[0-9]\." my-text)) user> my-matcher # user> (re-find my-matcher) "1." user> my-matcher # user> (re-find my-matcher) "2." user> my-matcher # user> (re-find my-matcher) "3." user> (re-find my-matcher) nil ;;;; ;;;; Snippet #54 user> (with-open [out (java.io.BufferedWriter. (java.io.FileWriter. "buecher.ini"))] (binding [*out* out] (println "[Programming Clojure]") (println "Autor=Stuart Halloway") (println "Jahr=2009") (println "") (println "[PCL]") (println "Autor=Peter Seibel"))) nil ;;;; ;;;; Snippet #55 user> (with-open [in (java.io.BufferedReader. (java.io.FileReader. "buecher.ini"))] (let [sec-re #"\[([a-zA-Z0-9_ -]+)\]" kv-re #"([a-zA-Z0-9_-]+)=(.*)"] (loop [x (.readLine in) sec "Global" acc {}] (if (not x) acc ;; abschliessende Rueckgabe (let [secm (re-matcher sec-re x) kvm (re-matcher kv-re x)] (cond (.find secm) ;; neue Section (recur (.readLine in) (second (re-groups secm)) acc) (.find kvm) ;; key-value-Paar (recur (.readLine in) sec (assoc-in acc [sec (nth (re-groups kvm) 1)] (nth (re-groups kvm) 2))) ;; default ignoriere Zeile :else (recur (.readLine in) sec acc))))))) {"PCL" {"Autor" "Peter Seibel"}, "Programming Clojure" {"Jahr" "2009", "Autor" "Stuart Halloway"}} ;;;; ;;;; Snippet #56 user> (doto (java.util.Properties.) (.load (java.io.BufferedReader. (java.io.FileReader. "/etc/java-6-sun/net.properties")))) # ;;;; ;;;; Snippet #57 (defn haste-mal-ne-map [] (println "Hier haste ne Map") {:landkarte "Schweiz"}) user> (def o (with-meta (haste-mal-ne-map) {:mein-meta true})) Hier haste ne Map #'user/o user> o {:landkarte "Schweiz"} user> (meta o) {:mein-meta true} ;;;; ;;;; Snippet #58 (defn einfach-mult [werte] (reduce * werte)) (defn float-mult [^Floats werte] (reduce * werte)) user> (time (dotimes [_ 1000] (einfach-mult (range 1000)))) "Elapsed time: 281.683 msecs" nil user> (time (dotimes [_ 1000] (float-mult (range 1000)))) "Elapsed time: 99.402 msecs" nil ;;;; ;;;; Snippet #59 user> (def trio-lst '("JaJaJa" "Kummer" "Broken hearts")) #'user/trio-lst user> (first trio-lst) "JaJaJa" user> (rest trio-lst) ("Kummer" "Broken hearts") user> (next trio-lst) ("Kummer" "Broken hearts") user> (cons "Achtung Achtung" trio-lst) ("Achtung Achtung" "JaJaJa" "Kummer" "Broken hearts") user> (type (next trio-lst)) clojure.lang.PersistentList ;;;; ;;;; Snippet #60 user> (def trio-vec ["JaJaJa" "Kummer" "Broken hearts"]) user> (first trio-vec) "JaJaJa" user> (rest trio-vec) ("Kummer" "Broken hearts") user> (next trio-vec) ("Kummer" "Broken hearts") user> (cons "Achtung Achtung" trio-vec) ("Achtung Achtung" "JaJaJa" "Kummer" "Broken hearts") user> (type (next trio-vec)) clojure.lang.PersistentVector$ChunkedSeq ;;;; ;;;; Snippet #61 user> (def trio-juv (java.util.Vector.)) #'user/trio-juv user> (.addElement trio-juv "JaJaJa") nil user> (.addElement trio-juv "Kummer") nil user> (.addElement trio-juv "Broken hearts") nil user> trio-juv # user> (first trio-juv) "JaJaJa" user> (rest trio-juv) ("Kummer" "Broken hearts") user> (next trio-juv) ("Kummer" "Broken hearts") user> (cons "Achtung Achtung" trio-juv) ("Achtung Achtung" "JaJaJa" "Kummer" "Broken hearts") ;;;; ;;;; Snippet #62 user> (def abc (map (fn [x] (printf "<%d> " x) (* 2 x)) (range 100))) #'user/abc ;;;; ;;;; Snippet #63 user> (def adam (do (println "und eval") "sapfel")) und eval #'user/adam user> adam "sapfel" ;;;; ;;;; Snippet #64 (defn platzhalter-fuer-komplizierte-fn [x] (* x x)) user> (defn test-komplizierte-fn [n] (take n (map platzhalter-fuer-komplizierte-fn (iterate inc 0)))) #'user/test-komplizierte-fn user> (test-komplizierte-fn 10) (0 1 4 9 16 25 36 49 64 81) ;;;; ;;;; Snippet #65 user> (doseq [x (take 5 (iterate inc 0))] (println "x ist jetzt" x)) x ist jetzt 0 x ist jetzt 1 x ist jetzt 2 x ist jetzt 3 x ist jetzt 4 user> (doseq [x (take 2 (iterate inc 0)) y (take 3 (iterate inc 10))] (println "x und y sind jetzt" x y)) x und y sind jetzt 0 10 x und y sind jetzt 0 11 x und y sind jetzt 0 12 x und y sind jetzt 1 10 x und y sind jetzt 1 11 x und y sind jetzt 1 12 ;;;; ;;;; Snippet #66 user> (def schuessel (doall (map (fn [x] (printf "<%d> " x) (* 2 x)) (range 5)))) <0> <1> <2> <3> <4> #'user/schuessel user> schuessel (0 2 4 6 8) user> (def sieb (dorun (map (fn [x] (printf "<%d> " x) (* 2 x)) (range 5)))) <0> <1> <2> <3> <4> #'user/sieb user> sieb nil ;;;; ;;;; Snippet #67 ;; trivial: concat user> (concat [1 2 3] '(A B C) {:samson "uiuiui" :tiffy "rosa"}) (1 2 3 A B C [:samson "uiuiui"] [:tiffy "rosa"]) ;; drop, take und split: user> (drop-while #(< % 5) (range 10)) (5 6 7 8 9) user> (take-while #(< % 5) (range 10)) (0 1 2 3 4) user> (split-with #(< % 5) (range 10)) [(0 1 2 3 4) (5 6 7 8 9)] ;; Eine Seq aus Java Properties user> (doseq [it (take 4 (reverse (System/getProperties)))] (println (.getKey it) "=" (.getValue it))) sun.cpu.isalist = sun.desktop = gnome sun.cpu.endian = little sun.io.unicode.encoding = UnicodeLittle ;; 0 zwischen die Ziffern 0-9 user> (interpose 0 (range 10)) (0 0 1 0 2 0 3 0 4 0 5 0 6 0 7 0 8 0 9) ;; Komma zwischen Strings, oft folgt darauf str user> (interpose "," ["Ene" "Mene" "Miste"]) ("Ene" "," "Mene" "," "Miste") ;; Sortieren mit Keyword als Key-Funktion user> (def albums [{:t "Three Friends" :jahr 1972} {:t "Acquiring the Taste" :jahr 1971} {:t "Gentle Giant" :jahr 1970} {:t "Octopus" :jahr 1972}]) #'user/albums user> (sort-by :jahr albums) ({:t "Gentle Giant", :jahr 1970} {:t "Acquiring the Taste", :jahr 1971} {:t "Three Friends", :jahr 1972} {:t "Octopus", :jahr 1972}) ;;;; ;;;; Snippet #68 user> (def leute (line-seq (java.io.BufferedReader. (java.io.FileReader. "leute.txt")))) #'user/leute user> leute ("Jochen" "Frank" "Tim" "Tobias" "Sascha") user> (def abzaehl-reim (str "ene mene miste es rappelt in der kiste " "ene mene meck und du bist weg")) #'user/abzaehl-reim user> (def abzaehler (seq (.split abzaehl-reim " "))) #'user/abzaehler user> abzaehler ("ene" "mene" "miste" "es" "rappelt" "in" "der" "kiste" "ene" "mene" "meck" "und" "du" "bist" "weg") user> (partition 2 (interleave (cycle leute) abzaehler)) (("Jochen" "ene") ("Frank" "mene") ("Tim" "miste") ("Tobias" "es") ("Sascha" "rappelt") ("Jochen" "in") ("Frank" "der") ("Tim" "kiste") ("Tobias" "ene") ("Sascha" "mene") ("Jochen" "meck") ("Frank" "und") ("Tim" "du") ("Tobias" "bist") ("Sascha" "weg")) user> (first (last (partition 2 (interleave (cycle leute) abzaehler)))) "Sascha" ;;;; ;;;; Snippet #69 (defn byte-seq [rdr] (let [naechstes (.read rdr)] (when (< -1 naechstes) (lazy-seq (cons naechstes (byte-seq rdr)))))) ;;;; ;;;; Snippet #70 user> (use '(clojure.java [io :only (reader)])) nil user> (with-open [r (reader "buecher.ini")] (doall (apply str (map char (take 21 (byte-seq r)))))) "[Programming Clojure]" ;;;; ;;;; Snippet #71 (defn safe-deref [x] (try (deref x) (catch Exception e nil))) user> (count (filter #(fn? (safe-deref %)) (map second (ns-publics 'clojure.core)))) 509 ;;;; ;;;; Snippet #72 user> (let [alle (apply hash-set (map second (ns-publics 'clojure.core))) fnks (filter #(fn? (safe-deref %)) alle)] (doseq [t (clojure.set/difference alle fnks)] (println t))) #'clojure.core/*read-eval* #'clojure.core/*warn-on-reflection* ;; .. Ausgabe verkürzt #'clojure.core/*3 #'clojure.core/*allow-unresolved-vars* nil user> (let [alle (apply hash-set (map second (ns-publics 'clojure.core))) fnks (filter #(fn? (safe-deref %)) alle)] (doseq [t (distinct (map #(type (safe-deref %)) (clojure.set/difference alle fnks)))] (println t))) clojure.lang.MultiFn clojure.lang.RT$1 clojure.lang.Var clojure.lang.LineNumberingPushbackReader nil clojure.lang.Namespace java.io.OutputStreamWriter java.lang.Boolean clojure.lang.PersistentArrayMap java.lang.String clojure.lang.RT$3 clojure.core.VecNode java.io.PrintWriter clojure.lang.Compiler$CompilerException java.lang.Integer nil ;;;; ;;;; Snippet #73 (defn erzeuge-addierer [const] (fn [x] (+ const x))) user> (def test-addierer (erzeuge-addierer 4)) #'user/test-addierer user> (test-addierer 6) 10 user> (let [addier-4 (erzeuge-addierer 4) addier-2 (erzeuge-addierer 2)] (list (addier-4 5) (addier-4 10) (addier-2 5) (addier-2 10) (addier-2 (addier-4 1)))) (9 14 7 12 7) ;;;; ;;;; Snippet #74 (defn f0 [] "f0") (defn g0 [] "g0") (defn h0 [] "h0") user> (def j0 (juxt f0 g0 h0)) #'user/j0 user> (j0) ["f0" "g0" "h0"] (defn f1 [x] (str "f1" x)) (defn g1 [x] (str "g1" x)) (defn h1 [x] (str "h1" x)) user> (def j1 (juxt f1 g1 h1)) #'user/j1 user> (j1 "-> ein arg") ["f1-> ein arg" "g1-> ein arg" "h1-> ein arg"] ;;;; ;;;; Snippet #75 user> (def data [1 2 3 5 4 3 2 6]) #'user/data user> (def minmax (juxt #(apply min %) #(apply max %))) #'user/minmax user> (minmax data) [1 6] ;;;; ;;;; Snippet #76 user> (def zentrale {:durchwahl 0 :fax 99 :aktiv "Iris"}) #'user/zentrale user> (def zent-dienst (partial assoc zentrale :aktiv)) #'user/zent-dienst user> (zent-dienst "Andrea") {:durchwahl 0, :fax 99, :aktiv "Andrea"} user> (zent-dienst "Sylvia") {:durchwahl 0, :fax 99, :aktiv "Sylvia"} ;;;; ;;;; Snippet #77 user> (with-open [r (java.io.BufferedReader. (java.io.FileReader. "/etc/hosts" ))] (apply str (take 9 (repeatedly #(char (.read r)))))) "127.0.0.1" user> (with-open [r (-> "/etc/hosts" java.io.FileReader. java.io.BufferedReader.)] (apply str (take 9 (repeatedly #(-> r .read char))))) "127.0.0.1" ;;;; ;;;; Snippet #78 user> (require '(clojure xml)) nil user> (alias 'x 'clojure.xml) nil user> (x/emit {:tag :project, :content [{:tag :version, :content ["1.2.0"]} {:tag :url :content ["http://clojure.org"]}]}) 1.2.0 http://clojure.org nil ;; neue REPL starten user> (require '(clojure [xml :as x])) nil ;; (x/emit {:tag :project, ... } wie oben ;; Ausgabe ebenfalls wie oben ;;;; ;;;; Snippet #79 user> (read-string "(println \"Hallo Welt\")") (println "Hallo Welt") user> (read (java.io.PushbackReader. (java.io.FileReader. (java.io.File. "./shebang.clj")))) (println "Direkt ausführbares Programm") user> (read-string "'(1 2 3)") (quote (1 2 3)) ;;;; ;;;; Snippet #80 user> (defn zeige-historie [] (println [*1 *2 *3])) #'user/zeige-historie user> (+ 33 44) 77 user> (* 3 3) 9 user> (str "Jetzt kommt ein Karton!") "Jetzt kommt ein Karton!" user> (zeige-historie) [Jetzt kommt ein Karton! 9 77] nil user> (zeige-historie) [nil Jetzt kommt ein Karton! 9] nil user> (zeige-historie) [nil nil Jetzt kommt ein Karton!] nil user> (zeige-historie) [nil nil nil] nil ;;;; ;;;; Snippet #81 user> (def schachteln ["Schachtel" ["Karton" "Kasten" "Kästchen" ["Truhe" "Schrank"] "Kiste"] "Box"]) #'user/schachteln user> (println schachteln) [Schachtel [Karton Kasten Kästchen [Truhe Schrank] Kiste] Box] nil user> (binding [*print-level* 1] (println schachteln)) [Schachtel # Box] nil user> (binding [*print-level* 2] (println schachteln)) [Schachtel [Karton Kasten Kästchen # Kiste] Box] nil user> (binding [*print-level* 3] (println schachteln)) [Schachtel [Karton Kasten Kästchen [Truhe Schrank] Kiste] Box] nil ;;;; ;;;; Snippet #82 user> (def herta ^{:greta "Alpha Beta"} ["Peter" "The Greater"]) #'user/herta user> (meta herta) {:greta "Alpha Beta"} user> (binding [*print-meta* true] (prn herta)) ^{:greta "Alpha Beta"} ["Peter" "The Greater"] nil ;; aber: user> (binding [*print-meta* true] (println herta)) [Peter The Greater] nil ;;;; ;;;; Snippet #83 user> (def berta "See you spaeter, Alligator") user> (prn berta) "See you spaeter, Alligator" user> (binding [*print-dup* true] (prn berta)) "See you spaeter, Alligator" nil user> (def berta ["See you spaeter," "Alligator"]) #'user/berta user> (binding [*print-dup* true] (prn berta)) ["See you spaeter," "Alligator"] ;;;; ;;;; Snippet #84 user> (def foto-db {:root "/home/foto/bilder" :files ["img_0001.jpg" "img_0002.jpg"]}) ;;;; ;;;; Snippet #85 (defn speicher-foto-db [db f] (binding [*out* (java.io.FileWriter. f)] (prn db))) user> (speicher-foto-db foto-db "foto-daten.clj") nil ;;;; ;;;; Snippet #86 (defn lese-foto-db [f] (read (java.io.PushbackReader. (java.io.FileReader. (java.io.File. f))))) user> (lese-foto-db "foto-daten.clj") {:root "/home/foto/bilder", :files ["img_0001.jpg" "img_0002.jpg"]} ;;;; ;;;; Snippet #87 user> (time (speicher-foto-db {:root "/home/foto/bilder" :files (vec (repeat 10000 "img.jpg"))} "test-fotos.clj")) "Elapsed time: 295.783 msecs" nil user> (time (do ;; zum Unterdruecken des Resultats (lese-foto-db "test-fotos.clj") nil)) "Elapsed time: 88.126 msecs" nil ;;;;