square :: Float->Float
square x = x * x

fact0 ::Integer->Integer
fact0 n = if (n==0) then 1 else n * fact0(n-1)

-- "standard" recursive version
fact :: Integer -> Integer
fact 0 = 1
fact n = n * fact (n-1)

fact1 :: Int -> Int
fact1 0 = 1
fact1 n = n * fact1(n-1)

-- another "standard" recursive version
fact2 :: Integer -> Integer
fact2 n | n == 0 = 1
        | n > 0  = n * fact (n-1)

-- inductively recursive version
fact3 :: Integer -> Integer
fact3 0 = 1
fact3 (n+1) = (n+1) * fact n

-- lazily evaluated iterative version
fact4 :: Integer -> Integer
fact4 0 = 1
fact4 n = foldl (*) 1 [2..n]

fact5 ::Integer->Integer
fact5 n = tfact n 1 
	  where tfact 0 m = m
		tfact n m = tfact (n-1) (n*m)

foldl' :: (a -> b -> a) -> a -> [b] -> a
foldl' f a []     = a
foldl' f a (x:xs) = (foldl' f $! f a x) xs

-- eagerly (strict) evaluated iterative version
fact6 :: Integer->Integer
fact6 0 = 1
fact6 n = (foldl' (*) 1 [1..n])

ones = 1:ones

succ1 = \n -> n + 1

succ2 = (\a -> \b -> a + b) 1

succ3 n = n + 1

msucc (h:t) = succ3 h : map (\n->n+1) t


primes :: [Integer]
primes = sieve [2 .. ] -- Sieve of Eratosthenes
sieve (x:xs) = x : sieve [y | y <- xs, (y `rem` x)/=0]

nthprime n = take n primes