-- examples from lecture on lazy evaluation
-- dave@chalmers.se 2010-12-07

-- for timing
import System.Time
import System.CPUTime

import Data.Char
import Network.HTTP.Base(urlEncode)
import Data.List(foldl')


primes :: [Integer] 
primes = sieve [2..] 

sieve (x:xs) = 
     x : sieve [ y | y <- xs, y `mod` x /= 0 ]

-----------------------------------------------
primes' :: [Integer]
primes' = 2 : [ y | y <- [3,5..], 
                and [ y `mod` x /= 0| x <- upToRoot y ] ]
 where
  upToRoot x = let r =  floor . sqrt . fromInteger $ x 
               in takeWhile (<= r) primes'

---------------------------------------

headFile f = do 
  c <- readFile f
  let c' = unlines . take 5 . lines $ c 
  putStrLn c'


-- lazy IO example
encodeLines = interact $ 
   unlines . map urlEncode . lines 

---------------------------------------------
sum' :: [Integer] -> Integer
sum' [] = 0
sum' (x:xs) = x + sum' xs

million = 1000000 :: Integer  

average :: [Integer] -> Integer
average xs = sum xs `div` 
             fromIntegral (length xs)

average2 :: [Integer] -> Integer
average2 = uncurry div . foldl' f (0,0) 
   where f (s,l) n = let s' = s + n
                         l' = l + 1
                     in s' `seq` l' `seq` (s',l')

test = do 
  let x = undefined :: String
  print x

speedTest e1 e2 = do
  t1 <- getCPUTime
  print e1 -- forces the evaluation of e1 now
  t2 <- getCPUTime
  print e2
  t3 <- getCPUTime
  putStrLn ("first expression:  " ++ show (t2-t1))
  putStrLn ("second expression: " ++ show (t3-t2))