(* Carsten Schuermann *)
(* Case analysis example *)

let
  fun rev (nil, L) = L
    | rev (H :: T, L) = rev (T, H :: L)
    
  fun append (nil, L) = L
    | append (H :: T, L) = H :: append (T, L)
    
  fun map F nil = nil
    | map F (H :: T) = F H :: map F T
    
  fun foldr F V nil = V
    | foldr F V (H :: T) = F (H, foldr F V T)
    
  fun foldl F V nil = V
    | foldl F V (H :: T) = foldr F (F (H, V)) T
    
  fun plus L = foldl op+ 0 L
    
  fun mult L = foldl op* 1 L
    
  fun exists P L = foldl (fn (x, y) => P x orelse y) false L
    
  fun forall P L = foldl (fn (x, y) => P x andalso y) true L

  fun interval n m = 
      if n = m then [m]
      else n :: (interval (n + 1) m)

  fun sieveSingle n L = foldr (fn (x, y) => if x mod n = 0 then
			       y else (x :: y)) nil L 
  
  fun sieve L = foldr (fn (x, L) =>  x :: sieveSingle x L) nil L

  fun zip nil L = nil
    | zip L nil = nil
    | zip (H1 :: T1) (H2 :: T2) = (H1, H2) :: zip T1 T2
in
  (append ([1,2,3], [4,5,6]),
   exists  (fn x => x = 6) [1,4,7],
   forall  (fn x => x > 0) [1,4,7],
   interval 42 52,
   sieve (interval 2 100))
end