Listen und Funktionen höherer Ordnung

main :: IO ()
main = do
  let z = [5, 3, 9, 1, 7] :: [Int]
  print (head z, last z, init z, tail z)
  print (length z, sum z, product z, maximum z, minimum z)
  print (take 2 z, drop 2 z, splitAt 2 z, reverse z)
  print (z !! 2, elem 9 z, notElem 9 z)
  print (0 : z, z ++ [11], [1, 2] ++ [3])
  print ([1 .. 5], [1, 3 .. 11], [10, 8 .. 1], ['a' .. 'e'])
  print (null z, null [])
  print (replicate 3 'x', concat [[1], [2, 3]], concatMap show [1, 2, 3])
  print (zip [1, 2, 3] "abc", unzip [(1, 'a'), (2, 'b')])
  print (zipWith (+) [1, 2, 3] [10, 20, 30])
  print (lookup 2 [(1, "eins"), (2, "zwei")])
  print (words "ein kurzer Satz", unwords ["a", "b"], lines "x\ny", unlines ["a", "b"])

main :: IO ()
main = do
  let z = [1 .. 10] :: [Int]
  print (map (* 2) z)
  print (filter even z)
  print (foldr (+) 0 z)                        -- von rechts falten
  print (foldl (flip (:)) [] "abc")             -- von links falten
  print (foldl (\acc x -> acc * 10 + x) 0 [1, 2, 3])
  print (all even z, any (> 9) z)
  print (takeWhile (< 4) z, dropWhile (< 8) z, span even [2, 4, 5, 6], break (> 3) z)
  print (scanl (+) 0 [1, 2, 3, 4])
  print (iterate (* 2) 1 !! 10)
  print (sum (map (^ 2) (filter odd z)))
  print (length (filter (\x -> x `mod` 3 == 0) z))
  print (zip3 [1, 2] "ab" [True, False])
  print (foldr (\x acc -> if x > 3 then x : acc else acc) [] z)

main :: IO ()
main = do
  print [x * x | x <- [1 .. 10]]
  print [x | x <- [1 .. 20], x `mod` 3 == 0]
  print [(x, y) | x <- [1 .. 3], y <- "ab"]
  print [(a, b, c) | c <- [1 .. 20], b <- [1 .. c], a <- [1 .. b], a * a + b * b == c * c]
  print [if even x then "gerade" else "ungerade" | x <- [1 .. 4]]
  print [c | c <- "Haskell Programmierung", c `elem` "aeiou"]
  print (sum [1 / fromIntegral (n * n) | n <- [1 .. 1000 :: Int]] :: Double)
  let teiler n = [d | d <- [1 .. n], n `mod` d == 0]
  print (teiler 28, sum (init (teiler 28)) == 28)
  print [x | Just x <- [Just 1, Nothing, Just 3]]

import Data.Char (toUpper, isDigit, ord, chr, isAlpha)
import Data.List (sort, sortBy, sortOn, nub, group, partition, isPrefixOf, isSuffixOf, isInfixOf, intercalate, transpose, foldl', tails, subsequences, permutations)
import Data.Ord (comparing, Down (..))

main :: IO ()
main = do
  print (sort [3, 1, 2], sortBy (comparing negate) [3, 1, 2], sortOn Down [3, 1, 2])
  print (sortOn snd [(1, 'c'), (2, 'a'), (3, 'b')])
  print (nub [1, 2, 1, 3, 2])
  print (map (\g -> (head g, length g)) (group (sort "mississippi")))
  print (partition even [1 .. 8])
  print ("Has" `isPrefixOf` "Haskell", "ell" `isSuffixOf` "Haskell", "ske" `isInfixOf` "Haskell")
  print (intercalate ", " ["a", "b", "c"], transpose [[1, 2, 3], [4, 5, 6]])
  print (foldl' (+) 0 [1 .. 100000])
  print (map toUpper "hallo", filter isDigit "a1b22", ord 'A', chr 98)
  print (take 3 (tails [1, 2, 3]), length (subsequences [1 .. 4]), length (permutations [1 .. 4]))
  print (zip "abc" [1 ..])
  print (maximum (map length (words "ein kleiner langer Satz")))