import Prelude hiding (take,repeat,iterate)

-- List of all ascending numbers:
from :: Int -> [Int]
from n = n : from (n+1)

take :: Int -> [a] -> [a]
take n _    | n<=0 = []
take _ []          = []
take n (x:xs)      = x : take (n-1) xs

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

-- List of all prime numbers:
primes :: [Int]
primes = sieve (from 2)

-- List of all Fibonacci numbers
fibgen :: Integer -> Integer -> [Integer]
fibgen n1 n2 = n1 : fibgen n2 (n1+n2)

fibs :: [Integer]
fibs = fibgen 0 1

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


-- Repeat its argument in a list:
repeat :: a -> [a]
repeat x = x : repeat x

-- Iterates a function on an element
iterate :: (a -> a) -> a -> [a]
iterate f x = x : iterate f (f x)

-- Enumerate numbers where first two numbers are given for the distance.
fromThen :: Int -> Int -> [Int]
fromThen n1 n2 = iterate ((n2-n1) +) n1

-- Number interval between two numbers.
fromTo :: Int -> Int -> [Int]
fromTo n1 n2 = if n1>n2 then []
                        else n1 : fromTo (n1+1) n2

fromThenTo :: Int -> Int -> Int -> [Int]
fromThenTo n1 n2 mx = let d = n2-n1
                      in if d>0 && n1>mx || d<0 && n1<mx
                           then []
                           else n1 : fromThenTo (n1+d) (n2+d) mx

-- Factorial function: a compact definition
fac :: Int -> Int
fac n = foldr (*) 1 [1..n]

numlines :: Int -> [String]
numlines n = map (uncurry (++))
                 (zip (map show [1..]) (take n (repeat ". Zeile")))

-- A cyclic structure:
cyclic = let ones = 1 : ones
         in ones !! 1000000