Pattern Matching, Guards und Rekursion

beschreibe :: Int -> String
beschreibe 0 = "null"
beschreibe 1 = "eins"
beschreibe n
  | n < 0 = "negativ"
  | even n = "gerade"
  | otherwise = "ungerade"

erstes :: [a] -> Maybe a
erstes [] = Nothing
erstes (x : _) = Just x

laenge :: [a] -> Int
laenge [] = 0
laenge (_ : rest) = 1 + laenge rest

summe :: [Int] -> Int
summe [] = 0
summe (x : xs) = x + summe xs

tuplePlus :: (Int, Int) -> Int
tuplePlus (a, b) = a + b

main :: IO ()
main = do
  mapM_ (putStrLn . beschreibe) [0, 1, -5, 4, 7]
  print (erstes [10, 20], erstes ([] :: [Int]))
  print (laenge "Haskell", summe [1 .. 100], tuplePlus (3, 4))
  let liste@(kopf : _) = [5, 6, 7]       -- as-Muster: ganze Liste und Kopf
  print (kopf, length liste)

bmi :: Double -> Double -> String
bmi gewicht groesse
  | wert < 18.5 = "Untergewicht"
  | wert < 25 = "Normalgewicht"
  | wert < 30 = "Übergewicht"
  | otherwise = "Adipositas"
  where
    wert = gewicht / groesse ^ 2

wochentag :: Int -> String
wochentag n = case n of
  1 -> "Montag"
  2 -> "Dienstag"
  _ | n `elem` [6, 7] -> "Wochenende"
    | otherwise -> "anderer Tag"

kreis :: Double -> (Double, Double)
kreis r = (flaeche, umfang)
  where
    flaeche = pi * r ^ 2
    umfang = 2 * pi * r

abstand :: (Double, Double) -> (Double, Double) -> Double
abstand (x1, y1) (x2, y2) =
  let dx = x2 - x1
      dy = y2 - y1
   in sqrt (dx * dx + dy * dy)

main :: IO ()
main = do
  putStrLn (bmi 70 1.75)
  print (map wochentag [1, 2, 6, 3])
  print (kreis 1)
  print (abstand (0, 0) (3, 4))
  print (if 10 > 5 then "größer" else "kleiner")

fib :: Int -> Integer
fib n = go n 0 1
  where
    go 0 a _ = a
    go k a b = go (k - 1) b (a + b)       -- Akkumulator: Endrekursion

ggT :: Int -> Int -> Int
ggT a 0 = a
ggT a b = ggT b (a `mod` b)

potenz :: Integer -> Int -> Integer
potenz _ 0 = 1
potenz b e
  | even e = let h = potenz b (e `div` 2) in h * h
  | otherwise = b * potenz b (e - 1)

collatz :: Int -> [Int]
collatz 1 = [1]
collatz n
  | even n = n : collatz (n `div` 2)
  | otherwise = n : collatz (3 * n + 1)

hanoi :: Int -> String -> String -> String -> [(String, String)]
hanoi 0 _ _ _ = []
hanoi n von nach hilfe = hanoi (n - 1) von hilfe nach ++ [(von, nach)] ++ hanoi (n - 1) hilfe nach von

main :: IO ()
main = do
  print (map fib [0 .. 10])
  print (fib 90)
  print (ggT 48 18)
  print (potenz 2 100)
  print (collatz 6)
  print (length (hanoi 10 "A" "C" "B"))
  print (hanoi 2 "A" "C" "B")

naturalZahlen :: [Integer]
naturalZahlen = [1 ..]

fibs :: [Integer]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

primzahlen :: [Int]
primzahlen = sieb [2 ..]
  where sieb (p : xs) = p : sieb [x | x <- xs, x `mod` p /= 0]

main :: IO ()
main = do
  print (take 5 naturalZahlen)
  print (take 12 fibs)
  print (takeWhile (< 40) primzahlen)
  print (fst (1, undefined))               -- undefined wird nie ausgewertet
  print (take 3 (cycle "ab"), take 3 (repeat 'x'), take 4 (iterate (* 2) 1))
  print (head (filter ((> 1000) . (^ 2)) [1 ..]))