Chapter 1, Living Coljure

ch1.clj

;; The Structure of Clojure
;; osnovni tipovi
'alo ;; simboli
12 ;; brojevi
12.3 ;; brojevi
12/3 ;; razlomci
:dzezva ;; kljucne reci
true ;; boolean
nil ;; corak
"ja sam teskt" ;; stringovi
\c ;; karakteri


;; osnovne racunske operaicije
(+ 1 1)
(- 1 100000)
(* 1 1)
(/ 1 21)

;; stringovi, karakteri
"vizantija"
\s ;; karakter, char

;; boolean
true
false

;; odustvo vrednosti
nil

;; slozeniji matematicki izrazi
(+ (+ 2 3) (* (/ 22 7) 1) 8)

;; kolekcije
;; liste
'(1 2 "jam" "pomorandza")
;; sve je lista, odnosno neki podatak u clojure-u
'(+ 1 24) 
;; elemente mozemo razdvajati i zapetom
'(1, 2, 4, 50, "tekst", +)
;; ali se to izbegava, nije idiomatski

;; uzimanje elemenata liste
(first '("talking heads" "grand funk"))
(first '(+ * - /))
(last '(+ * - /))

(rest '(+ * - /)) ;; vraca ostatak liste

;; pravljenje nove liste
(cons 5 '())
(cons 5 '(2 3))


;; pravljenje v2
(list 1 2 3)

;; liste su dobre za pristup elementima sa pocetka
;; ze elemente iz sredine koristimo
;; vektori 
[:nesto 1 2 :nesto2]
(first [1 2 3])
(rest [3 2 1]) ;; rest uvek vraca listu!
;; prisup elementu iz sredine
(nth [1 2 3 ] 2)
(last [1 100 200]) ;; last je brzi nad vektorima nego nad listama

;; sve kolkecije su imutabilne i trajne
(count '(1 2 2 2 2 2))

(conj '(2 2 2) 100) ;; pocetak
(conj [12 23 45] 5) ;; kraj
;; conj dodaje na element na najefikasniji nacin za datu strukturu

;; mape
{:srbija "beograd", :nemacka "berlin"}
(get {:srbija "beograd", :nemacka "berlin"} :srbija)
(get {:srbija "beograd", :nemacka "berlin"} :ne-postoji "nije pronadjeno:(")
(:srbija {:srbija "beograd", :nemacka "berlin"})
(keys {:srbija "beograd", :nemacka "berlin"}) ;; vraca listu kljuceva
(vals {:srbija "beograd", :nemacka "berlin"} ) ;; vraca listu vrednosti
(assoc {:srbija "beograd", :nemacka "berlin"} :hrvatska "zagreb") ;; dodaje novi kv par
(dissoc {:srbija "beograd", :nemacka "berlin"} :nemacka) ;; uklanja kv par
(merge {:k1 "v1" :k2 "v2"}
       {:m1 "g1" :m2 "g2" :k1 "v45"} ;; pregazice staru vrednost od k1!!!
)
;; skupovi
#{:reg :green :blue :purple} ;; skup, nema duplikata

;; operacije sa skupovima
(clojure.set/union #{1 2 3} #{-4 -5 -6})
(clojure.set/difference #{1 2 3} #{2 3 4}) ;; ne komutira
(clojure.set/intersection #{1 2 3} #{"hi" 1 2})
;; od listi, mapa i vektora mozemo napraviti skup
(set '(+ * - /))
(set {:srbija "beograd" :spanija "madrid"}) ;; kv postaju vektori!
;; elementima pristupamo isto kao i u mapi
(#{:beograd :berlin :bridges} :bridges)
(:beograd #{:beograd :berlin :bridges})

;; mozemo da proveravamo da li skup sadrzi neki element
(contains? #{:beograd :berlin :bridges} :prag)
(contains? #{:beograd :berlin :bridges} :berlin)
;; gornja funkcija vraca true ili false vrednosti
(conj #{:beograd :berlin :bridges} :rio) ;; dodaje element
(disj #{:beograd :berlin :bridges} :berlin) ;; uklanja element

;; binding
;; simbole pravimo sa def i dodeljujemo im neku vrednost
;; ovo se zove binding u clojure terminoligiji
;; def deluje na globalnom nivou
(def developer "Alice")
user/developer ;; puno ime promenljive, svaka je vezana za ns

(let [developer "ALISA"]
  developer
) ;; vezuje promenljive za leksicki opseg
;; sta se desi u let-u
;; ostaje u let-u
developer ;; still Alice 

;; DEFiNisanje funkcija
(defn hello [] "helooaa") ;; defn, ime fje, vektor argumenata, telo fje
(hello)

;; dzem fja
(defn kupi-dzem [dzem1 dzem2] {:dzem1 dzem1 :dzem2 dzem2})
(kupi-dzem "kajsija" "jagoda") ;; vraca mapu

;; anonimne funkcije
(fn [] "anonimna funkcija")
(def otpozdrav (fn [ime] (str "Vidimo se " ime "!")))
(otpozdrav "David Bern")

;; crna magija anon funkcija
(#(str "Hello " %) "bla") ;; wtf
(#(str "Hei" %1 %2 %3 ) "hahhaha" "hohoho" "hehehe") ;; 3 argumenta uzima

;; OOP jezici koriste klase za enkapsulaciju
;; coljure koristi namespace

(ns alice-wonder)
(def wonder "kitkat")
user/developer ;; prebaceni smo u drugi ns, nije vidljiv vise user ns
*ns* ;; vraca ime trenutnog ns-a
;; var-ovi su vezani za ns u kome su stvoreni

(require 'clojure.set) ;; kao import u python-u

(ns wonderland
  (:require [clojure.set :as s]))

(defn common-fav-foods [f1 f2] 
  (let [food1-set (set f1)
        food2-set (set f2)
        common-foods (s/intersection food1-set food2-set)]
        (str "Common food" common-foods)))
(common-fav-foods [:jam :brownies :toast]
                  [:bread :jam :pasteta])