anchor.diff:  (length (1 2 3)) ; => 3
   (_ "foobar") ; => 6
   
  -;;; Haskell fluff
  +;;;;;;;;;;;;;;;
  +; Haskell fluff
  +
  +; First item in list
   (head (1 2 3)) ; => 1
  +; List from second to last elements in list
   (tail (1 2 3)) ; => (2 3)
  +; Last item in list
   (last (1 2 3)) ; => 3
  +; Reverse of `tail`
   (init (1 2 3)) ; => (1 2)
  +; List from first to specified elements in list
   (take 1 (1 2 3 4)) ; (1 2)
  +; Reverse of `take`
   (drop 1 (1 2 3 4)) ; (3 4)
  +; Lowest value in list
   (min (1 2 3 4)) ; 1
  +; Highest value in list
   (max (1 2 3 4)) ; 4
  +; If value is in list or object
   (elem 1 (1 2 3)) ; true
   (elem "foo" {"foo":"bar"}) ; true
   (elem "bar" {"foo":"bar"}) ; false
  +; Reverse list order
   (reverse (1 2 3 4)) ; => (4 3 2 1)
  +; If value is even or odd
   (even 1) ; => false
   (odd 1) ; => true
  +; Split string into list of strings by whitespace
   (words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
  +; Join list of strings together.
   (unwords ("foo" "bar")) ; => "foobar"
   (pred 21) ; => 20
   (succ 20) ; => 21
  
positive.code: ; JavaScript-style uneven division.
  (/ 5 2) ; => 2.5
  
  ; Nesting forms words as you expect.
  (* 2 (+ 1 3)) ; => 8
  
  ; There's a boolean type.
  
negative.code: ; which are just things inside parens separated by whitespace
  not_in_form
  (in_form)
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; 1. Numbers, Strings, and Operators
  
  ; Whip has one number type (which is a 64-bit IEEE 754 double, from JavaScript).
  3 ; => 3
  