Computing with Clojure

• Lisp: small core, code-as-data, abstraction
  

• Functional, emphasis on immutability
  

• Support concurrency & managed state
  

• Expose and embrace host platforms
  

• Limits to change post standardization
  

• Core data structures mutable, not extensible
  

• No concurrency in specs
  

• Standard Lisps are their own platforms
  

• Good implementations already exist for JVM
  

• VM, not OS, is target platform of the future
  
  • Type system
    
  • Dynamic enforcement and safety
    
  • Garbage collection
    
  • Libraries
    
  • Bytecode, just-in-time compilation
    

user=> (+ 3 4)  ; Read
                ; Eval
7               ; Print
user=>          ; Loop

(op ... )

• op can be either:
  
  • special operator or macro
    
  • expression which yields a function
    
    • more generally, something invocable
      

42           ; Long
6.022e23     ; Double

42N          ; BigInt
1.0M         ; BigDecimal
22/7         ; Ratio

"hello"      ; String
\e           ; Character

true  false        ; Booleans

nil                ; null

+  Fred  *bob*     ; Symbols

:alpha  :beta      ; Keywords

(4 :alpha 3.0)     ; List

[2 "hello" 99]     ; Vector

{:a 1, :b 2}       ; Map

#{alice jim bob}   ; Set

• Note: commas are whitespace
  

user=> (use 'clojure.repl)

user=> (doc when)
;; -------------------------
;; clojure.core/when
;; ([test & body])
;; Macro
;;   Evaluates test. If logical true, evaluates
;;   body in an implicit do.
;;=> nil

user=> (find-doc "sequence")
;; ... all definitions with "sequence"
;; in their documentation ...
;;=> nil

user=> (apropos "map")
;;=> (sorted-map ns-unmap zipmap map mapcat
;;  sorted-map-by map? amap struct-map
;;  proxy-mappings pmap map-indexed
;;  ns-map array-map hash-map)

user=> (source take)
;; (defn take
;;   "Returns a lazy sequence of the first n items
;;   in coll, or all items if there are fewer than n."
;;   {:added "1.0"
;;    :static true}
;;   [n coll]
;;   (lazy-seq
;;    (when (pos? n)
;;      (when-let [s (seq coll)]
;;       (cons (first s) (take (dec n) (rest s)))))))
;;=> nil

user=> (dir clojure.repl)
;; apropos
;; demunge
;; dir
;; dir-fn
;; doc
;; find-doc
;; pst
;; root-cause
;; set-break-handler!
;; source
;; source-fn
;; stack-element-str
;; thread-stopper
;;=> nil

• Find the product of 314 and 159 using the REPL.
  

• Find the product of 314 and 159 using the REPL.
  

  user=> (* 314 159)
  ;=> 49926
  

• Transform the following expression into Clojure code: (42 + 17 * 9) / 12
  

• Transform the following expression into Clojure code: (42 + 17 * 9) / 12
  

  user=> (/ (* (+ 42 17) 9) 12)
  ;=> 177/4
  

• The extra whitespace helps show the structure
• Normally we would not use so much whitespace

• Again, extra whitespace to show structure

• Sequences look and behave like lists

• Similar to *splat in Ruby

• Re-use common names in different contexts
  
  • e.g. clojure.core/replace and clojure.string/replace
    

• Separate application "layers" or "components"
  

• Libraries
  

• Separate "public API" and "internal implementation"
  

;; In the namespace "foo.bar"
(defn hello [] (println "Hello, World!"))

;; In another namespace
(foo.bar/hello)   ; namespace-qualified

• Load: find source on classpath & eval it
  

• Alias: make shorter name for namespace-qualified symbols
  

• Refer: copy symbol bindings from another namespace into current namespace
  

• Import: make Java class names available in current namespace
  

• Creates namespace and loads, aliases what you need
  
  • At top of file
    

• Refers all of clojure.core
  

• Imports all of java.lang
  

  ;; in file foo/bar/baz_quux.clj
  (ns foo.bar.baz-quux)
  

• Loads the namespace if not already loaded
  
  • Argument is a symbol, must be quoted
    

• Have to refer to things with fully-qualified names
  

  (ns my-ns
    (:require clojure.set))
  ;;=> nil
  
  (clojure.set/union #{1 2} #{2 3 4})
  ;;=> #{1 2 3 4}
  

• Loads the namespace if not already loaded
  
  • Argument is a vector, must be quoted
    

• Aliases the namespace to alternate name
  

  (ns my-ns
    (:require [clojure.set :as set]))
  ;;=> nil
  
  ;; "set" is an alias for "clojure.set"
  (set/union #{1 2} #{2 3 4})
  ;;=> #{1 2 3 4}
  

• Loads the namespace if not already loaded
  
  • Argument is a symbol, must be quoted
    

• Refers all symbols into current namespace
  

• Warns when symbols clash
  

(ns my-ns
  (:use clojure.string))
;; WARNING: reverse already refers
;; to: #'clojure.core/reverse in
;; namespace: user, being reversed
;; by: #'clojure.string/reverse
;; ...
;;=> nil

(reverse "hello")
;;=> "olleh"

• Loads the namespace if not already loaded
  
  • Argument is a vector, must be quoted
    

• Refers only specified symbols into current namespace
  

  (ns my-ns
    (:use [clojure.string :only (join)]))
  ;;=> nil
  (join "," [1 2 3])
  ;;=> "1,2,3"
  

• Makes Java classes available w/o package prefix in current namespace
  
  • Argument is a list, quoting is optional
    

• Does not support aliases/renaming
  

• Does not support Java's import *
  

  (ns my-ns
    (:import (java.io FileReader File))
  ;;=> nil
  (FileReader. (File. "readme.txt"))
  ;;=> #<FileReader ...>
  

(ns name
  (:require [some.ns.foo :as foo]
            [other.ns.bar :as bar])
  (:use [this.ns.baz :only (a b c)]
        [that.ns.quux :only (d e f)])
  (:import (java.io File FileWriter)
           (java.net URL URI)))

• For require/use to work, have to find code defining namespace
  

• Clojure converts namespace name to path and looks on CLASSPATH
  
  • Dots in namespace name become /
    
  • Hyphens become underscores
    

• Idiomatic to define namespace per file
  

• in-ns switches to namespace
  
  • Creates namespace if it doesn't exist
    

• Argument is a symbol, must be quoted
  

• REPL always starts in namespace "user"
  

  user=> (in-ns 'foo.bar.baz)
  ;;=> nil
  foo.bar.baz=>
  

• Just a taste of macros
• Clojure has fewer parens than Java!

• Clojure types are Java types
• clojure.lang.BigInt fixes bugs in Java BigInteger

• *read-only

• Java methods are not Clojure functions
• Can't store them, pass them as arguments
• Can wrap them in functions when necessary

;; make a function to invoke .length on arg
(fn [obj] (.length obj))

• Find the code in src/tutorial/midi.clj
  

• Can you play a progression of notes?
  

• "It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures." - Alan J. Perlis

• Clojure provides extensive facilities for representing and manipulating data
• Small number of data structures
• Seq abstraction common across data structures & more
• Large library of functions across all of them

• The values of simple types are immutable
  • 4, 0.5, true
• In Clojure, the values of compound data structures are immutable too
  • Key to Clojure's concurrency model
• Code never changes values, generates new ones to refer to instead
• Persistent data structures ensure this is efficient in time and space

• New values built from old values + modifications
• New values are not full copies
• New value and old value are both available after 'changes'
• Collection maintains its performance guarantees for most operations
• All Clojure data structures are persistent

• Sequential
  • List, Vector
• Associative
  • Map, Vector
• Both types support declarative destructuring

• Singly-linked lists

()              ;=> the empty list
(1 2 3)         ; error because 1 not function
(list 1 2 3)    ;=> (1 2 3)
'(1 2 3)        ;=> (1 2 3)
(conj '(2 3) 1) ;=> (1 2 3)

• Indexed, random-access, array-like

[]              ;=> the empty vector
[1 2 3]         ;=> [1 2 3]
(vector 1 2 3)  ;=> [1 2 3]
(vec '(1 2 3))  ;=> [1 2 3]
(nth [1 2 3] 0) ;=> 1
(conj [1 2] 3)  ;=> [1 2 3]

• Key => value, hash table, dictionary

{}                  ;=> the empty map
{:a 1 :b 2}         ;=> {:a 1 :b 2}
(:a {:a 1 :b 2})    ;=> 1
({:a 1 :b 2} :a)    ;=> 1
(assoc {:a 1} :b 2) ;=> {:a 1 :b 2}
(dissoc {:a 1} :a)  ;=> {}
(conj {} [:a 1])    ;=> {:a 1}

• Helper functions access data via path specified by keys

(def jdoe {:name "John Doe", :address {:zip 27705}})

(get-in jdoe [:address :zip]) ;=> 27705

(assoc-in jdoe [:address :zip] 27514)
;;=> {:name "John Doe", :address {:zip 27514}}

(update-in jdoe [:address :zip] inc)
;;=> {:name "John Doe", :address {:zip 27706}}

• Set of distinct values

#{}                  ;=> the empty set
#{:a :b}             ;=> #{:a :b}
(#{:a :b} :a)        ;=> :a
(conj #{} :a)        ;=> #{:a}
(contains? #{:a} :a) ;=> true

(require '[clojure.set :as set])
(set/union #{:a} #{:b})              ;=> #{:a :b}
(set/difference #{:a :b} #{:a})      ;=> #{:b}
(set/intersection #{:a :b} #{:b :c}) ;=> #{:b}

• Declarative way to pull apart compound data
  • vs. explicit, verbose access
• Works for both sequential and associative data structures
• Nests for deep, arbitrary access

• Destructuring works in fn and defn params, let bindings
  • And anything built on top of them

• Provide vector of symbols to bind by position
  • Binds to nil if there's no data

(def stuff [7 8 9 10 11]) ;=> #'user/stuff
;; Bind a, b, c to first 3 values in stuff
(let [[a b c] stuff]
  (list (+ a b) (+ b c)))
;;=> (15 17)
(let [[a b c d e f] stuff]
  (list d e f))
;;=> (10 11 nil)

• Can get "everything else" with &
  • Value is a sequence

(def stuff [7 8 9 10 11]) ;=> #'user/stuff
(let [[a & others] stuff]
  (println a)
  (println others))
;; 7
;; (8 9 10 11)
;;=> nil

• Idiomatic to use _ for values you don't care about

(def stuff [7 8 9 10 11]) ;=> #'user/stuff
(let [[_ & others] stuff] ; skip the first one
  (println others)))
;; (8 9 10 11)
;;=> nil

• Provide map of symbols to bind by key
  • Binds to nil if there's no value

(def m {:a 7 :b 4}) ;=> #'user/m
(let [{a :a, b :b} m]
  [a b])
;;=> [7 4]

• Keys can be inferred from vector of symbols to bind

(def m {:a 7 :b 4}) ;=> #'user/m
(let [{:keys [a b]} m]
  [a b])
;;=> [7 4]
(let [{:keys [a b c]} m]
  [a b c])
;;=> [7 4 nil]

• Use :or to provide default values for bound keys

(def m {:a 7 :b 4}) ;=> #'user/m
(let [{:keys [a b c]
       :or {c 3}} m]
  [a b c])
;;=> [7 4 3]

• Applying vector of keys to & binding emulates named args

(defn game [planet & {:keys [human-players computer-players]}]
  (println "Total players: " (+ human-players computer-players)))

(game "Mars" :human-players 1 :computer-players 2)
;; Total players: 3

• Abstraction for representing iteration
• Backed by a data structure or a function
  • Can be lazy and/or "infinite"
• Foundation for large library of functions

• (seq coll)
  • If collection is non-empty, return seq object on it, else nil
  • Can't recover input source from seq
• (first coll)
  • Returns the first element
• (rest coll)
  • Returns a sequence of the rest of the elements
• (cons x coll)
  • Returns a new sequence: first is x, rest is coll

• Can treat any Clojure data structure as a seq
  • Associative structures treated as sequence of pairs

(def a-list '(1 2 3)) ;=> #'user/a-list

(first a-list) ;=> 1

(second a-list) ;=> 2

(rest a-list) ; seq

• Can map a generator function to a seq
• Seq is lazy, can be infinite
  • Can process more than fits in memory

(def a-range (range 1 4)) ;=> #'user/a-range

(first a-range) ;=> 1

(second a-range) ;=> 2

(rest a-range) ; seq

• REPL always prints sequences with parens
  • But it's not a list!
• Infinite sequences take a long time to print

(set! *print-length* 10) ; only print 10 things

• Generators
  • list, vector, map, SQL ResultSet, Stream, Directory, Iterator, XML, …
• Operations
  • map, filter, reduce, count, some, replace, …
• Generators * Operations = Power!

(seq [1 2 3]) ;=> (1 2 3)  ; not a list
(range) ;=> (0 1 2 ... infinite
(range 3) ;=> (0 1 2)
(range 1 7 2) ;=> (1 3 5)
(iterate #(* 2 %) 2) ;=> (2 4 8 16 ... infinite
(re-seq #"[aeiou]" "clojure") ;=> ("o" "u" "e")

(take 3 (range)) ;=> (0 1 2)
(drop 3 (range)) ;=> (3 4 5 ... infinite
(map #(* % %) [0 1 2 3]) ;=> (0 1 4 9) ; vector treated as seq
(filter even? (range)) ;=> (0 2 4 6 ... infinite
(apply str (interpose "," (range 3))) ;=> "0,1,2"

(reduce + (range 4)) ;=> 6
(reduce + 10 (range 4)) ;=> 16
(into #{} "hello") ;=> #{\e \h \l \o}
(into {} [[:x 1] [:y 2]]) ;=> {:x 1, :y 2}
(some {2 :b 3 :c} [1 nil 2 3]) ;=> :b

• Sequence library surface space is big
• Most things you want to do are in there somewhere
• If you find yourself explicitly iterating, look for a function
• The Clojure Cheatsheet helps
• http://clojure.org/cheatsheet

(def fibs            ; define a sequence called fibs...
  (map first         ; that maps the first value of a pair across...
    (iterate         ; a lazy, infinite sequnce that's generated by...
      (fn [[a b]]    ; a function that destructures a pair of args...
        [b (+ a b)]) ; and returns the next pair in the sequence...
      [0 1])))       ; starting at [0 1]

(take 5 fibs)        ; consume as many as you'd like
;;=> (0 1 1 2 3)

• Go back to midi.clj from the previous exercise.
  

• Play the song in this data structure:
  

  (def notes
    [{:note 60 :duration 1}
     {:note 62 :duration 1}
     {:note 64 :duration 1}
     {:note 60 :duration 1}
     {:note 60 :duration 1}
     {:note 62 :duration 1}
     {:note 64 :duration 1}
     {:note 60 :duration 1}
     {:note 64 :duration 1}
     {:note 65 :duration 1}
     {:note 67 :duration 2}
     {:note 64 :duration 1}
     {:note 65 :duration 1}
     {:note 67 :duration 2}])
  

• Go back to your greeting code from the functions section. Change this so it works for any amount of people.
  

  (messenger "Hello" "Clinton")
  ;; Hello, Clinton!
  
  (messenger "Hello" "Clinton" "Alan")
  ;; Hello, Clinton and Alan!
  
  (messenger "Hello" "Clinton" "Alan" "all of you")
  ;; Hello, Clinton, Alan, and all of you!
  
  (messenger "Hello" "Clinton" "Alan" "Rich" "all of you")
  ;; Hello, Clinton, Alan, Rich, and all of you!
  

• last, butlast, list*, and clojure.string/join will come in very helpful in this exercise.
  

(defn messenger
  ([greeting who] (str greeting ", " who "!"))
  ([greeting who1 who2] (str greeting ", " who1 " and " who2 "!"))
  ([greeting who1 who2 & whos]
     (str
      greeting ", "
      (clojure.string/join ", " (butlast (list* who1 who2 whos)))
      ", and " (last whos) "!")))

• Everything in Clojure is an expression
  
  • Always returns a value
    
  • A block of multiple expressions returns the last value
    
    • E.g., let, do, fn
      
  • Expressions exclusively for side-effects return nil
    

• Flow control operators are expressions too
  

• Composable, can use them anywhere
  
  • Less duplicate code
    
  • Fewer intermediate variables
    

(if true :truthy :falsey)
;;=> :truthy
(if (Object.) :truthy :falsey) ; objects are true
;;=> :truthy
(if [] :truthy :falsey) ; empty collections are true
;;=> :truthy

(if false :truthy :falsey)
;;=> :falsey
(if nil :truthy :falsey) ; nil is false
;;=> :falsey
(if (seq []) :truthy :falsey) ; seq on empty coll is nil
;;=> :falsey

(str "2 is " (if (even? 2) "even" "odd"))
;;=> "2 is even"

; else-expression is optional
(if (true? false) "impossible!")
;;=> nil

• Multiple expressions per branch
  

• Last value in branch returned
  

  (if (even? 5)
    (do (println "even")
        true)
    (do (println "odd")
        false)) ;=> false
  ;; odd
  

• Series of tests and expressions
  

• :else expression is optional
  

  (cond
   test1 expression1
   test2 expression2
   ...
   :else else-expression)
  

(let [x 5]
  (cond
   (< x 2) "x is less than 2"
   (< x 10) "x is less than 10"))
;;=> "x is less than 10"

(let [x 11]
  (cond
   (< x 2) "x is less than 2"
   (< x 10) "x is less than 10"
   :else "x is greater than or equal to 10"))
;;=> "x is greater than or equal to 10"

• Go back to your greeting code. It is kind of a complex mess. Use flow control to make it awesome.
  

(defn messenger [greeting & whos]
  (let [x (count whos)]
    (apply str greeting ", "
           (cond
             (= x 0) ["!"]
             (< x 3) (conj (vec (interpose " and " whos)) "!")
             :else 
               (concat (vec (interpose ", " (butlast whos))) 
                       [", and " (last whos) "!"])))))

• Clojure provides loop and the sequence abstraction
  

• loop is "classic" recursion
  
  • Closed to consumers, lower-level
    

• Sequences represent iteration as values
  
  • Consumers can partially iterate
    

• Iterates over a sequence
  
  • Similar to Java's foreach loop
    

• If a lazy sequence, doseq forces evaluation
  

  (doseq [n (range 3)]
    (println n))
  ;; 0
  ;; 1
  ;; 2
  ;;=> nil
  

• Similar to nested foreach loops
  

• Processes all permutations of sequence content
  

• Evaluate expression n times
  

  (dotimes [i 3]
    (println i))
  ;; 0
  ;; 1
  ;; 2
  ;;=> nil
  

• Evaluate expression while condition is true
  

  (while (.accept socket)
    (handle socket))
  

• List comprehension, NOT a for-loop
  

• Generator function for sequence permutation
  

  (for [x [0 1]
        y [0 1]]
    [x y])
  ;;=> ([0 0] [0 1] [1 0] [1 1]) ; seq
  

• JDK7 introduces try-with-resources
  

• Clojure provides with-open for similar purposes
  

  (require '[clojure.java.io :as io])
  (with-open [f (io/writer "/tmp/new")]
    (.write f "some text"))