clojure

1.1 basics

1. hashmap {}
   

   (get MAP key default) (get-in MAP [:key :path] default)

   (MAP :key) (MAP :key default) (:key MAP default)

   into

   => (def m {:a "jeu"})
   => (into m {:b "kk"})
   {:a "jeu", :b "kk"}
   

   also see assoc

   (assoc {:a 1} :b 2)
   ;f{:a 1 :b 2}
   
   

2. vectors []
   

   conj adds one to the vector end (get VECTOR index)

   => (def z [m])
   => (into z #{{:b "kk"}})
   [{:a "jeu"} {:b "kk"}]
   

3. lists '()
   

   no get, nth instead conj adds to lost beginning

4. hashed sets #{}
   

   hash-set creates conj (set VECTOR) (contains? #{} :key) get

5. functions
   

   (defn function-name
          "doc string"
          [args]
          (res))
   

   ; multi arity
   (defn funk
     ([arg1 arg3] (something))
     ([arg1] (something)))
   
   (defn funk
     [arg & rest]
     (something))
   

   anonymous (fn [args] (body)) #(* % 3) arg gets inserted in % further %1 %2 %&

   1. let
      

      (let [x 0] x) ;0

6. loop
   

   it’s almost exactly like a function, that allows tail calling

   (loop [arg 0] (recur (inc arg))) ; infinite loop.  =recur= calls the func
   

   1. Destructuring
      

      (defn my-first-fink
        [[first-thing second-thing]]
        [first-thing second-thing])
      

      same for maps: [{lat :lat lng :lng}] var name to keyword or: {:keys [lat lng]} keep OG {:keys [lat lng] :as treasure-location}

7. Sequence functions
   

   filter, take, drop, take-while, drop-while, some, sort, sortBy, concat repeat, repeatedly lazy

   1. reduce, map
      

      (reduce + 15 [1 2 3 4])
      (reduce + [1 2 3 4])
      (map str ["a" "b" "c" "d"] ["A" "B" "C"])
      ; => ("aA" "bB" "cC")
      

8. Collection functions
   

   empty, every

9. Function functions
   

   partial, apply, complement comp, memoize

10. comp vs -> (pipe)
    

    (def m {:a {:b {:c "hi!"}}})
    (-> m :a :b :c)
    ; "hi!"
    ((comp :a :b :c) m)
    ; nil
    ((comp :c :b :a) m)
    ; "hi!"
    
    

11. regular expressions
    

    re-find seems pretty useful

    (re-find #"^left-" "left-eye")
    ; => "left-"
    (re-find #"^left-" "cleft-chin")
    ; => nil
    (re-find #"^left-" "wongleblart")
    ; => nil
    

12. time
    

    (time (vampire-related-details 0)) (Thread/sleep 1000)

13. cons
    

    cons(truct) a seq conj(oin) an item

    => (def m (seq {:a 1 :b 2 :c 3}))
    ([:a 1] [:b 2] [:c 3])
    => (into {} m)
    {:a 1, :b 2, :c 3}
    

14. require
    

    (require ’[the-divine-cheese-code.visualization.svg :as svg])

    … cheaply (use ’[the-divine-cheese-code.visualization.svg :as svg])