anchor.diff:  
   == Functions are Values
   
  -In functional programming languages, functions are values.
  +In functional programming languages, functions are first class citizens.
  +This means that functions can be treated like variables.
  +We can pass them around as arguments to other functions.
  +Return them from functions as a result.
  +Assign variables a function as their value.
   
   For instance, say we want to write a function that will double a number.
   In most languages, you can define a function like so.
   
   [source, java]
   ----
  -public static Int double (int a ) {
  +public static Int timesTwo (int a ) {
       return 2 * a;
   }
  +----
  +
  +Or in Clojure,
  +
  +[source, clojure]
  +----
  +(defn times-two [a] (* 2 a))
   ----
   
   This should look very familiar.
  
positive.code: 
  [source, clojure]
  ----
  (def bands [
      {:name "Kiss"
       :genre :rock}
      {:name "Led Zeppelin"
       :genre :rock}
      {:name "Michael Jackson"
       :genre :pop}
      {:name "Eminem"
       :genre :rap}])
  
  (defn rock-band? 
      [band]
  
negative.code: (greet-dog "Sparky")
  ;; => "Woof woof Sparky!"
  ----
  
  == Anonymous Functions
  
  An anonymous function is a function without a name.
  In Clojure these can be defined in two ways, `defn` and the literal `#(...)`.
  Creating a function with `defn` immediately binds it to a name, `fn` just creates a function.
  
  Lets go back to the example of the bands.
  We wrote a function called `rock-band?` to determine whether or not our band was a rock band.
  This is a one-off operation, we're not going to use it anywhere else in our code.
  We can save ourselves some keystrokes by using an anonymous function.
  
  [source, clojure]
  ----
  (def rock-bands
      (filter 
          (fn [band] (= :rock (:genre band))) 
          bands))
  ----
  
  Even more concisely, using the function literal, we can define `rock-bands` like so.
  
  [source, clojure]
  ----
  (def rock-bands (filter #(= :rock (:genre %)) bands))
  ----
      
  The function literal supports multiple arguments via `%1`, `%2`, and so on.
  
  [source, clojure]
  ----
  #(println %1 %2 %3)
  ----
  
  If you're writing an anonymous function, the literal syntax is nice because it's so compact.
  However, beyond a few arguments, the syntax can become difficult to read.
  In that case, using `fn` may be more appropriate.
  
  
  
  
  
  
  
  
  
  
  
  
  
  