content: -- !!! a file mailed us by Ryzard Kubiak. This provides a good test of the code
  -- !!! handling type signatures and recursive data types.
  
  module ShouldSucceed where
  
  data Boolean = FF | TT
  data Pair a b = Mkpair a b
  data List alpha = Nil | Cons alpha (List alpha)
  data Nat = Zero | Succ Nat
  data Tree t = Leaf t | Node (Tree t) (Tree t) 
  
  idb :: Boolean -> Boolean
  idb x = x      
  
  
  swap :: Pair a b -> Pair b a
  swap t = case t of 
             Mkpair x y -> Mkpair y x 
  
  neg :: Boolean -> Boolean
  neg b = case b of 
            FF -> TT 
            TT -> FF 
  
  nUll :: List alpha -> Boolean
  nUll l = case l of 
             Nil -> TT
             Cons y ys  -> FF 
  
  idl ::  List a -> List a
  idl xs  = case xs of
             Nil -> Nil 
             Cons y ys -> Cons y (idl ys)
       
  add :: Nat -> Nat -> Nat
  add a b = case a of 
              Zero -> b 
              Succ c -> Succ (add c b) 
  
  app :: List alpha -> List alpha -> List alpha
  app  xs zs  = case xs of
                    Nil -> zs 
                    Cons y ys  -> Cons y (app ys zs) 
                   
  lEngth :: List a -> Nat
  lEngth xs = case xs of 
                Nil -> Zero  
                Cons y ys  -> Succ(lEngth ys) 
  
  before :: List Nat -> List Nat
  before xs = case xs of
                Nil -> Nil
                Cons y ys -> case y of 
                                Zero -> Nil
                                Succ n -> Cons y (before ys)       
  
  rEverse :: List alpha -> List alpha
  rEverse rs = case rs of
                 Nil -> Nil
                 Cons y ys -> app (rEverse ys) (Cons y Nil) 
               
  
  flatten :: Tree alpha -> List alpha
  flatten t = case t of
                Leaf x   -> Cons x Nil 
                Node l r -> app (flatten l) (flatten r)
           
  sUm :: Tree Nat -> Nat
  sUm t = case t of
            Leaf t   -> t
            Node l r -> add (sUm l) (sUm r) 
  
  
  