anchor.diff:  we have to upgrade our Racket version a bit:
   
   [code,scheme]
  -----------------------------------------------------------------------------
  +----
   (define (qs-2 fun lst)
     (if (empty? lst)
         lst
  
positive.code: quicksort can readily handle numbers, strings, or lists of chars, all
  thanks to the power of this line right here:
  
  `quicksort :: (Ord a) => [a] -> [a]`
  
  _Especially_ the `(Ord a)` bit: that's the Ord typeclass, which imports
  types that Haskell knows how to put in order, thus allowing a statically
  
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.
  