anchor.diff:  we have to upgrade our Racket version a bit:
   
   [code,scheme]
  -----------------------------------------------------------------------------
  +----
   (define (qs-2 fun lst)
     (if (empty? lst)
         lst
  
positive.code:              (smaller (qs (for/list ((i tl) #:when (<= i hd)) i)))
               (larger (qs (for/list ((i tl) #:when (> i hd)) i))))
           (flatten (cons smaller (cons hd larger))))))
  ------------------------------------------------------------------
  
  So clearly, it's not exactly the _recursion_ that makes the example so
  cool. No, what makes the Haskell version cool is when you realize what
  
negative.code: For reference, the Haskell recursive quicksort looks like this:
  
  [code,haskell]
  ----
  quicksort :: (Ord a) => [a] -> [a]
  quicksort [] = []
  quicksort (x:xs) =
      let smallerSorted = quicksort [a | a <- xs, a <= x]
          biggerSorted = quicksort [a | a <- xs, a > x]
      in smallerSorted ++ [x] ++ biggerSorted
  ----
  
  I know, right? It's short and sweet, and using multiple recursion and
  list filtering to solve it takes a hell of a lot of the work out of it.
  