anchor.diff:  
   [source, clojure]
   ----
  -(def bands [
  -    {:name "Kiss"
  -     :genre :rock}
  -    {:name "Led Zeppelin"
  -     :genre :rock}
  -    {:name "Michael Jackson"
  -     :genre :pop}
  -    {:name "Eminem"
  -     :genre :rap}])
  +(def bands [{:name "Kiss"
  +             :genre :rock}
  +            {:name "Led Zeppelin"
  +             :genre :rock}
  +            {:name "Michael Jackson"
  +             :genre :pop}
  +            {:name "Eminem"
  +             :genre :rap}])
   
   (defn rock-band? 
       [band]
  
positive.code: The first will return a function as its result.
  The second will accept a function as an argument.
  
  Our first function will be called `adder`.
  It will take a number, `x`, as it's only argument and return a function.
  The function returned by `adder` will also take a single number, `a`, as it's argument and return `x + a`.
  
negative.code: 
  == 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 timesTwo (int a ) {
      return 2 * a;
  }
  ----
  
  Or in Clojure,
  
  [source, clojure]
  ----
  (defn times-two [a] (* 2 a))
  ----
  
  This should look very familiar.
  