import Prelude hiding (take, repeat, iterate)

-- Infinite list of all numbers: 0:1:2:3:4:...
allNats :: [Int]
allNats = from 0

from :: Int -> [Int]
from n = n : from (n+1)

-- Returns a prefix of a list.
take :: Int -> [a] -> [a]
take n _       | n <= 0 = []
take n []               = []
take n (x:xs)           = x : take (n-1) xs

-- Sieve of Eratosthenes:
sieve :: [Int] -> [Int]
sieve (p : xs) = p : sieve (filter (\x -> mod x p > 0) xs)

primes :: [Int]
primes = sieve (from 2)


-- Compute all Fibonacci numbers:
fibs :: [Int]
fibs = fibsgen 0 1
 where
  fibsgen :: Int -> Int -> [Int]
  fibsgen n1 n2 = n1 : fibsgen n2 (n1 + n2)

fib :: Int -> Int
fib n = fibs !! n


-- Computes the infinite list of some value:
repeat :: a -> [a]
repeat x = x : repeat x

-- Iterated application of some function
iterate :: (a -> a) -> a -> [a]
iterate f x = x : iterate f (f x)

test = iterate (+1) 0

-- All numbers in an interval: [n .. m]
fromTo :: Int -> Int -> [Int]
fromTo n m = if n > m then []
                      else n : fromTo (n+1) m

-- All numbers w.r.t. some increment step: [n1,n2 ..]
fromThen :: Int -> Int -> [Int]
fromThen n1 n2 = let d = n2-n1 in n1 : fromThen (n1+d) (n2+d)

-- All numbers w.r.t. some increment up to a maximum: [n1,n2 .. m]
fromThenTo :: Int -> Int -> Int -> [Int]
fromThenTo n1 n2 m =
  let d = n2 - n1
  in if (d>=0 && n1>m) || (d<0 && n1<m)
       then []
       else n1 : fromThenTo (n1+d) (n2+d) m

data Color = Red | Green | Yellow | Blue
  deriving (Read, Show, Enum, Bounded)


fac :: Int -> Int
fac n = foldr (*) 1 [1 .. n]

numLines :: [String]
numLines = map (uncurry (++)) (zip (map show [1 ..]) (repeat ". Zeile"))