content: -- We define these because we're starting from scratch.
  undefined = undefined;
  (.) f g x = f (g x);
  id x = x;
  data Bool = True | False;
  (==) x y = case x <= y of { True -> y <= x ; False -> x <= y };
  ifz n x y = case 0 == n of { True -> x ; False -> y };
  showsInt n = let
    { showsNonzero n = let { q = n/10 } in
      ifz n id ((.) (showsNonzero q) (chr (ord '0'+(n-(q*10))):) )
    } in ifz n ('0':) (showsNonzero n);
  tail xs = case xs of { [] -> undefined; (:) _ t -> t };
  (!!) xs n = case xs of { [] -> undefined; (:) h t -> ifz n h (t!!(n - 1)) };
  zipWith f xs ys = case xs of
    { [] -> []
    ; (:) x xt -> case ys of
      { [] -> []
      ; (:) y yt -> f x y : zipWith f xt yt
      }
    };
  
  -- One of the first Haskell examples I saw. It got my attention. How can it
  -- possibly work? And even after I understood it, I wondered: how do I write
  -- a compiler that can understand it? (Now, I know!)
  --
  -- Let f be the generating function for Fibonacci numbers. We have:
  --
  --   f = 0 + x + (f + f/x )x^2
  --
  -- This translates neatly to:
  
  fibs = 0 : (1 : zipWith (+) fibs (tail fibs));
  
  -- See M. Douglas McIlroy, "Power Series, Power Serious" for more examples.
  
  go _ = showsInt (fibs !! 30) "\n";
  