Beispiele

REPL_Beispiele.clj

;; Beispiele für die REPL

(+ 2 2)

; Listen
'(1 2 3 4 5 "ksdjksdfjkjsdf")

; Vektoren
[1 2 3 4 5]

; Zahlen
2

3

; Floats
3.0

; große Zahlen
2893283928390234809234823094802394


; Strings
"same"

; Booleans
true

false

; Sets
#{1 2 3}

; Maps
{:a 3 :b 4}

; Das ist die komplette Syntax von Clojure!

; Der folgende Aufruf verursacht eine Exception
; Java.lang.integer cannot be cast to java.lang.IFn
(1 2 3 4)

; das erste Argument ist eine Funktion restlichen sind Argumente, und 1 ist keine bekannte Funktion

(println 3)

(str "kjsdfksdfjkdsdf")

; quote Funktion ' ist abkürzung daf
; Vorteil der Prefix-Notation die Operator precedings brauche ich nicht
; ( 2 + 2 * 3) hier muss mal Klammern setzen um zu definieren wie gerechnet werden soll

; Maps
(def people {:pg "Andreas", st "Stefan"})

people

; Zugriffe auf Map sind Funktionen

(people :pg)
(:pg people) (Shortcut)

; Rationale Zahlen 
(/ 4 3)

(class (/3 4))
; liefert -> clojure.lang.Ratio

; Ein Teil von Clojure ist in Java implementiert, teile aber auch in Clojure selbst.

(class "skdjsdkdfksdf")


; Code is Data - Data is code

(format "Hello %s" "World") ; Code 

'(format "Hello %s" "World") ; Daten

; Mit eval kann der Code ausgewertet werden
(eval '(format "Hello %s" "World"))


;; Funktionen

; Anonyme Funktion
((fn [x] (format "Hello %s")) "Andreas")

; Funktionen sind nur "Daten" - Clojure ist Homoiconic
(def v (fn [x] (format "Hello %s" "World")))

; defn definiert Funktionen und weist sie zu

;; Funktionen können als Parameter durch die Gegend gereicht werden

(defn even [x] (= 0 (rem x 2))

(even 2)

(even 3)

(def a [1 2 3 4])

; Mappen einer Funktion über eine Liste
(map even a)

;; Structs 
(defstruct person :first :last :country)

(struct person "X" "Y")

; drunter steckt ne Map ...

(vector
(struct person ...)
(struct ...)

)

(defn is-andreas [x] (= (:first x) "Andreas"))

(filter is-stefan people)

; bisher alles aus der Lisp Welt

(new java.lang.String "abc")
(java.lang.String. "abc")

; Es gibt einige Abkürzungen die die Arbeit mit Java erleichtern 

; Zugriff auf statische Member
(java.io.File/separator)

(import '(java.io File))
(File/separator)

; Verwendung von Java-Methoden
(defn blank? [s] (every? #(Character/isWhitespace %) s))

(blank? "sdksdksdfjkjsd"))

(blank? "   ")

;Lazy Sequences - unendlich lange Listen

(inc 0)

(iterate inc 0)

; Iterate - Lazy Sequence constructor

(take 20 (iterate inc 0))

(def n (iterate (fn [x] (+ x 1)) 0)) ; lazy

(def fives (map #(+5 %) n)) ; lazy

; beliebig verschachtelbar

(take 20 fives)

; Fibonacci - Folge
(use 'clojure.contrib.lazy-seqs)

(source fibs)

(take 20 fibs)


; In Clojure gibt es nur Werte oder Referenzen

(ref "Hello")

(def r1 (ref "Hello"))

r1

(deref r1)

@r1  ist ein Shortcut

(ref-set r1 "Hello, World")
; -> Evalation aborted

; Können nur im Kontext einer Transaktion genutzt werden

(dosync (ref-set r1 "Hello, World"))

; Alle können lesen, aber keiner schreiben


(def sample-agent (agent ()))
(send sample-agent (fn [messges] (conj messages "Hello, world")))

@sample-agent


; Parallele Variante zur Map

(pmap #(+ 2 %) list)


;; Makros

(defn broken-slowed-down [time expression]
(Threas/sleep time)
(expression))

(broken-slowed-down 300 (+ 2 2))

; Verwenden eine Funktion wo ein Makro hätte verwendet werden müssen

(defmacro slowed-down [time expression]
(list 'do (list 'Thread/sleep time) expression))

(macroexpand-1 '(slowed-down 300 ( + 2 2)))


; Makro Beispiel:

(def *debug* true)

(defmacro log [body]
  (if *debug* `(printf "%s: %s\n" (java.util.Date.) ~body)))

(log "Hello, World")

; Tue Apr 27 19:06:43 CEST 2010: Hello, World

(macroexpand '(log "Hello, World"))

; Liefert:
; (if user/*debug*
; (printf "%s: %s\n" (java.util.Date.) "Hello, World"))


(macroexpand '(log (format "Hello, World %d" (* 9 9))))

; Liefert:
;(if *debug*
;  (printf "%s: %s\n" (java.util.Date.)
;(format "Hello, World %d" (* 9 9))))


; Beispiel aus "The Joy of Clojure"

(def AND #(and %1 %2)) 
(def rank (zipmap [- + * / AND =] (iterate inc 1))) 

(defn infix* [[a b & [c d e & more]]]
	(cond 
	  (vector? a) (recur (list* (infix* a) b c d e more))
	  (vector? c) (recur (list* a b (infix* c) d e more))
	  (ifn? b)   (if (and d (< (rank b 0) (rank d 0)))
	    (recur (list a b (infix* (list* c d e more))))
	    (recur (list* (b a c) d e more)))
	:else a))
	
(defn infix [& args]
  (infix* args))
  
(infix 21 / [1 + 2 * 3])


(defn all-eq? [& args]
  (apply = args))
  
(all-eq? 3 3 3 3 3 3 3 8)