Grundlagen
Hello World
main ist der Einstiegspunkt, putStrLn gibt mit Zeilenumbruch aus
-- GHCi interactive environment
-- launch: ghci (quit with :q)
-- simple arithmetic
> 2 + 3
5
-- function application (no parentheses needed)
> succ 5
6
-- define a function
> double x = x * 2
> double 10
20
-- lists
> [1,2,3,4]
[1,2,3,4]
-- strings are lists of chars
> "hello"
"hello"Kommentare
{- -} für mehrzeilige Kommentare
-- single line comment
{- multi-line comment
spanning multiple lines -}
{- nested {- comments -} are allowed -}
-- comments are ignored by the compilerGHCi Interaktiv
:t zeigt den Typ, :q beendet
-- hello.hs
main :: IO ()
main = putStrLn "Hello, World!"
-- run interpreted
-- runhaskell hello.hs
-- or compile to an executable
-- ghc hello.hs && ./hellolet-Bindung
let definiert lokale Variablen in einem do-Block
-- in GHCi, 'let' defines a binding (no 'in' needed)
> let x = 5
> let double n = n * 2
> x + double x
15
-- in a source file, top-level bindings need no 'let'
y = 10
-- 'let' inside an expression needs 'in'
z = let a = 2 in a * a -- 4Einrückungsregeln
Haskell verwendet Einrückung statt geschweifter Klammern
-- :t shows the type of an expression
> :t 'a'
'a' :: Char
> :t True
True :: Bool
> :t "hi"
"hi" :: [Char]
> :t (+)
(+) :: Num a => a -> a -> a
-- :info shows typeclass info
> :info NumDateien laden
:load lädt ein Modul in GHCi; :reload lädt es nach Änderungen neu. :browse listet alles, was ein Modul exportiert. :main führt das Programm mit Kommandozeilen-Argumenten aus. Das macht den REPL-Workflow geschmeidig.
-- GHCi commands
> :load MyModule.hs -- or :l
> :reload -- or :r, reload after edits
> :type main -- check a type
> :browse Data.List -- list a module's exports
> :main arg1 arg2 -- run main with args
-- :set +t auto-prints types of resultsTypen
Basistypen
:: annotiert Typen explizit
-- Int: bounded integer (platform-dependent)
x :: Int
x = 9
-- Integer: arbitrary-precision (unbounded)
big :: Integer
big = 2 ^ 100
-- Float / Double (prefer Double)
piVal :: Double
piVal = 3.14159
-- Bool
flag :: Bool
flag = True
-- Char (single Unicode character)
c :: Char
c = 'a'Funktionstypen
-> ist rechtsassoziativ, der letzte ist der Rückgabetyp
-- explicit type signature above a binding
age :: Int
age = 30
-- annotate an expression inline with ::
result = (5 :: Int) + 3
-- function signature
add :: Int -> Int -> Int
add x y = x + y
-- annotate a list
nums :: [Double]
nums = [1.0, 2.0, 3.0]Typvariablen
Kleinbuchstaben sind Typvariablen
-- 'a' is a type variable (polymorphic)
id' :: a -> a
id' x = x
-- works for any type
> id' 5
5
> id' "hello"
"hello"
-- length works on any list
length :: [a] -> IntMaybe-Typ
Maybe repräsentiert Berechnungen, die fehlschlagen können
-- '->' is right-associative
add :: Int -> Int -> Int
-- equivalent to: Int -> (Int -> Int)
-- takes a function as an argument
apply :: (a -> b) -> a -> b
apply f x = f x
-- returns a function
const' :: a -> b -> a
const' x y = xEither-Typ
Either wird für Fehlerbehandlung verwendet
-- Maybe: optional values
data Maybe a = Nothing | Just a
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- Either: a value or an error
data Either a b = Left a | Right b
-- convention: Left = error, Right = success
parse :: String -> Either String Int
parse s = Right (read s)Tupel & Listen-Typen
Tupel (a, b) halten eine feste Zahl von Werten, evtl. verschiedenen Typs. Listen [a] halten beliebig viele Werte desselben Typs. Der Tupel-Typ kodiert seine Größe; der Listen-Typ nicht.
-- tuple: (a, b)
pair :: (Int, String)
pair = (1, "one")
-- list: [a]
nums :: [Int]
nums = [1, 2, 3]
-- list of tuples
pairs :: [(Int, String)]
pairs = [(1, "a"), (2, "b")]
-- empty list keeps the polymorphic type
empty :: [a]
empty = []Typklassen
Eq-Typklasse
Eq definiert Gleichheitsvergleich
-- name, parameters, '=', body
double :: Int -> Int
double x = x * 2
-- application: just a space, no parentheses
> double 5
10
-- multiple parameters (curried)
add :: Int -> Int -> Int
add x y = x + y
> add 3 4
7Show und Read
Show/Read-Typklassen
-- application is left-associative
> max 3 5
5
> max (max 3 5) 7
7
-- '$' has the lowest precedence, right-associative
> sum (map (*2) [1..5])
30
> sum $ map (*2) [1..5] -- same, fewer parens
-- chain reads left to right
> putStrLn $ show $ sum [1..10]
55Num und Ord
Num für numerische Operationen, Ord für Sortiervergleich
-- wrap an operator in () to use as a function
> (+) 2 3
5
> (*) 4 5
20
-- sections: partial application of operators
> (+10) 5
15
> (3/) 12
0.25
> (/3) 12
4.0
-- backticks make a function infix
> 10 `div` 3
3
> 10 `mod` 3
1Functor-Typklasse
Functor ist mappable
-- (.) composes functions right to left
(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = f (g x)
> negate . sum $ [1,2,3]
-6
-- chaining
fn = ceiling . negate . tan
> fn (pi/4)
-1
-- point-free style
odd' = not . evenTypeinschränkungen
Links von => ist die Typeinschränkung
-- functions are first-class values
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
> applyTwice (+3) 10
16
> applyTwice (\x -> x*x) 2
16
-- pass functions to higher-order functions
> map (*2) [1..5]
[2,4,6,8,10]
> filter even [1..6]
[2,4,6]Infix & Präfix
Jede binäre Funktion lässt sich infix zwischen Backticks schreiben (3 `elem` xs), und jeder Operator präfix in Klammern (mod 10 3). Je nach Kontext das Lesbarste wählen.
-- infix operators can be written prefix with ()
> mod 10 3
1
> div 10 3
3
-- functions can be written infix with backticks
> 10 `mod` 3
1
> 10 `div` 3
3
-- elem: membership test, often infix
> 3 `elem` [1,2,3]
TrueFunktionen
Funktionsdefinition
Funktionsaufrufe benötigen keine Klammern
-- lists are homogeneous linked lists
nums :: [Int]
nums = [1, 2, 3, 4, 5]
-- strings are [Char]
chars = ['h','e','l','l','o']
str = "hello" -- same as chars
-- empty list
empty = []
-- cons (prepend) is O(1)
> 0 : [1,2,3]
[0,1,2,3]Mehrfachparameter-Funktionen
Alle Funktionen sind einparameterig (curried)
-- ranges
> [1..5]
[1,2,3,4,5]
-- with a step (first two elements)
> [2,4..10]
[2,4,6,8,10]
-- decreasing needs the step
> [5,4..1]
[5,4,3,2,1]
-- infinite lists (lazy)
> take 5 [1..]
[1,2,3,4,5]
> take 3 (cycle [1,2])
[1,2,1]Operatoren als Funktionen
() wandelt einen Operator in eine Funktion um
-- basic access (partial: crash on empty)
> head [1,2,3]
1
> tail [1,2,3]
[2,3]
> last [1,2,3]
3
> init [1,2,3]
[1,2]
-- safe helpers
> length [1,2,3]
3
> null []
True
> reverse [1,2,3]
[3,2,1]Funktionskomposition
. Operator komponiert Funktionen
-- '++' concatenates two lists
> [1,2] ++ [3,4]
[1,2,3,4]
-- ':' prepends a single element (O(1))
> 1 : [2,3]
[1,2,3]
-- concat flattens one level
> concat [[1,2],[3,4],[5]]
[1,2,3,4,5]
-- intercalate joins with a separator
> intercalate ", " ["a","b","c"]
"a, b, c"where-Klausel
where definiert Hilfsfunktionen am Ende einer Funktion
-- like mathematical set-builder notation
> [x*2 | x <- [1..5]]
[2,4,6,8,10]
-- with a predicate (filter)
> [x | x <- [1..10], even x]
[2,4,6,8,10]
-- multiple generators = Cartesian product
> [(x,y) | x <- [1,2], y <- ['a','b']]
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- with a let binding
> [x*y | x <- [1..3], let y = x+1]
[2,6,12]Häufige Listen-Funktionen
elem prüft Zugehörigkeit (oft infix). sum und product reduzieren Zahlenlisten. take/drop extrahieren oder entfernen einen Präfix. splitAt teilt an einem Index in ein Paar. Alle geben neue Listen zurück, da Listen unveränderlich sind.
-- membership (often written infix)
> elem 3 [1,2,3]
True
> 3 `elem` [1,2,3]
True
-- reductions
> sum [1..10]
55
> product [1..5]
120
-- take / drop a prefix
> take 3 [1..10]
[1,2,3]
> drop 3 [1..10]
[4,5,6,7,8,9,10]
-- split at an index
> splitAt 3 [1..6]
([1,2,3],[4,5,6])Musterabgleich
Grundlegender Musterabgleich
In Reihenfolge matchen, _ matcht alles
-- tuples can hold different types
pair :: (Int, String)
pair = (1, "hello")
triple :: (Int, String, Double)
triple = (1, "x", 3.14)
-- the size is part of the type
-- (1,2) and (1,2,3) are different typesListen-Musterabgleich
: trennt Kopf und Rest
-- fst/snd only work on pairs
> fst (1, "a")
1
> snd (1, "a")
"a"
-- swap exchanges the components
> swap (1, 2)
(2,1)
-- these do NOT work on triples
> fst (1, 2, 3) -- type error!Tupel-Musterabgleich
Jede Position eines Tupels matchen
-- destructure a tuple by position
describe :: (Int, String) -> String
describe (n, s) = show n ++ ": " ++ s
-- ignore components with _
firstOf :: (a, b, c) -> a
firstOf (x, _, _) = x
-- in a list comprehension
> [n | (n, _) <- [(1,'a'),(2,'b')]]
[1,2]as-Muster
@ behält den gesamten gematchten Wert
-- zip pairs elements from two lists
> zip [1,2,3] ['a','b','c']
[(1,'a'),(2,'b'),(3,'c')]
-- stops at the shorter list
> zip [1,2,3] [4,5]
[(1,4),(2,5)]
-- unzip splits a list of pairs
> unzip [(1,'a'),(2,'b')]
([1,2],"ab")case-Ausdruck
case für Musterabgleich innerhalb eines Funktionskörpers
-- list: same type, variable length
ints :: [Int]
ints = [1, 2, 3]
-- tuple: mixed types, fixed length
mixed :: (Int, String, Bool)
mixed = (1, "x", True)
-- list of tuples (tabular data)
people :: [(String, Int)]
people = [("Alice",30),("Bob",25)]
-- cannot mix types in a list
> [1, "two"] -- type errorGuards
Grundlegende Guards
otherwise ist ein Alias für True
-- match on literals, top to bottom
lucky :: Int -> String
lucky 7 = "LUCKY SEVEN!"
lucky _ = "Sorry, you're out of luck"
> lucky 7
"LUCKY SEVEN!"
> lucky 13
"Sorry, you're out of luck"Mehrfachparameter-Guards
Guards prüfen in Reihenfolge
-- empty list
isEmpty [] = True
isEmpty _ = False
-- head and tail (cons pattern)
head' :: [a] -> a
head' (x:_) = x
-- first two elements
firstTwo :: [a] -> [a]
firstTwo (x:y:_) = [x,y]
firstTwo xs = xswhere mit Guards
where kann von allen Guards geteilt werden
-- match by position
addPair :: (Int, Int) -> Int
addPair (x, y) = x + y
-- nested patterns
getAge :: (String, (Int, Int)) -> Int
getAge (_, (age, _)) = age
-- ignore with _
nameOf :: (String, Int) -> String
nameOf (name, _) = nameAs-Muster
As-Muster (name@pattern) binden einen Namen an den ganzen gematchten Wert und destrukturieren ihn zugleich. Nützlich, wenn man beides braucht — das Original und seine Teile — und teure Rekonstruktion vermeiden will.
-- '@' keeps the whole value AND its parts
firstLetter :: String -> String
firstLetter "" = "Empty string!"
firstLetter all@(x:_) =
"The first letter of " ++ all ++ " is " ++ [x]
> firstLetter "Haskell"
"The first letter of Haskell is H"Case-Ausdrücke
case führt Pattern Matching innerhalb eines Ausdrucks durch. Nützlich, wenn der Funktionskörper nach etwas Vorbereitung auf einen berechneten Wert verzweigen muss. Muster werden der Reihe nach probiert; falls nötig catch-all ergänzen.
-- pattern match inside any expression
describe :: [a] -> String
describe xs =
case xs of
[] -> "empty"
[_] -> "singleton"
_ -> "longer"
-- case on any value, e.g. an Ordering
classify n = case compare n 0 of
LT -> "negative"
EQ -> "zero"
GT -> "positive"Konstruktor-Muster
Muster können data-Konstruktoren wie Red, Nothing und Just matchen. So werden algebraische Datentypen dekonstruiert. Der Compiler warnt vor non-exhaustive Mustern — alle Konstruktoren abdecken.
-- match on data constructors
data Color = Red | Green | Blue
toString :: Color -> String
toString Red = "red"
toString Green = "green"
toString Blue = "blue"
-- match on Maybe
fromMaybe :: a -> Maybe a -> a
fromMaybe d Nothing = d
fromMaybe _ (Just x) = xWhere / Let
where-Klausel
where steht am Ende einer Funktionsdefinition
-- '|' tests boolean conditions in order
bmiTell :: Double -> String
bmiTell bmi
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| bmi <= 30.0 = "overweight"
| otherwise = "obese"
> bmiTell 22.0
"normal"let-in-Ausdruck
let-in ist ein Ausdruck, kann überall verwendet werden
-- otherwise is just True
otherwise :: Bool
otherwise = True
-- a signum implementation
signum' :: Int -> Int
signum' n
| n < 0 = -1
| n == 0 = 0
| otherwise = 1let im do-Block
let in einem do-Block benötigt kein in
-- multiple parameters
max' :: Int -> Int -> Int
max' a b
| a > b = a
| otherwise = b
-- shared helpers via where
bmiTell :: Double -> Double -> String
bmiTell w h
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| otherwise = "overweight"
where bmi = w / h^2let in Listen-Comprehension
let kann in Listen-Comprehensions verwendet werden
-- pattern matching: fixed values/structure
factorial 0 = 1
factorial n = n * factorial (n-1)
-- guards: ranges and conditions
clamp :: Int -> Int -> Int -> Int
clamp lo hi x
| x < lo = lo
| x > hi = hi
| otherwise = xif-then-else
In Haskell ist 'if' ein Ausdruck, der immer einen Wert zurückgibt — beide Zweige sind Pflicht. Für Mehrfach-Verzweigungen sind Guards sauberer als verschachtelte if-then-else. if-then-else passt zu einfachen Zwei-Wege-Entscheidungen.
-- 'if' is an expression that returns a value
abs' :: Int -> Int
abs' n = if n < 0 then -n else n
-- nested ifs (prefer guards for readability)
grade :: Int -> Char
grade n =
if n >= 90 then 'A'
else if n >= 80 then 'B'
else if n >= 70 then 'C'
else 'F'Listen
Listen-Grundlagen
Listen sind verkettete Listen gleichartiger Elemente
-- where: definitions at the bottom, scoped to a function
area :: Double -> Double -> Double
area w h = w * h_adj
where
h_adj = h * 0.9 -- adjust height
scale = 0.9 -- a helper
-- definitions can refer to each other
f x = a + b
where a = x * 2
b = a + 1 -- refers to aBereichslisten
Unterstützt Schrittweite und unendliche Listen
-- let <bindings> in <expr>
cylinder :: Double -> Double -> Double
cylinder r h =
let side = 2 * pi * r * h
top = pi * r^2
in side + 2 * top
-- scoped to the expression only
> let z = 5 in z * z
25
-- z is not in scope hereListen-Operationen
Grundlegende Listen-Operationsfunktionen
-- in do, 'let' needs no 'in'
main = do
let x = 5
y = 10
putStrLn $ "sum = " ++ show (x + y)
-- in a list comprehension, no 'in'
> [x*y | x <- [1..3], let y = x+1]
[2, 6, 12]Listen-Verkettung
++ verkettet, : stellt vorne an
-- where bindings support pattern matching
describe :: [a] -> String
describe xs = "head is " ++ show first
where (first:_) = xs
-- multiple where bindings
analyze :: [Int] -> String
analyze xs =
"sum=" ++ show s ++ ", len=" ++ show l
where s = sum xs
l = length xsListen-Comprehension
Ähnlich wie mathematische Mengen-Comprehensions
-- let: an expression, available wherever expressions go
-- (needs 'in', except in do/comprehension)
-- where: a declaration, attached to a function
-- (cannot be nested as an expression)
-- same result, two styles:
-- with let:
f x = let y = x+1 in y*y
-- with where:
f' x = y*y where y = x+1Tupel
Tupel-Grundlagen
Tupel können verschiedene Typen enthalten
-- base case + recursive case
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)
> factorial 5
120Tupel-Funktionen
fst/snd funktionieren nur bei Paaren
-- match [] then (x:xs)
length' :: [a] -> Int
length' [] = 0
length' (_:xs) = 1 + length' xs
sum' :: Num a => [a] -> a
sum' [] = 0
sum' (x:xs) = x + sum' xsTupel-Musterabgleich
Musterabgleich destrukturiert Tupel
-- carry the running result in an accumulator
factorial :: Int -> Int
factorial n = go n 1
where
go 0 acc = acc
go k acc = go (k-1) (k*acc)
-- sum with an accumulator
sumTo :: Int -> Int
sumTo n = go n 0
where go 0 acc = acc
go k acc = go (k-1) (k+acc)Quick Sort
Dieses berühmte Beispiel zeigt Haskell's Ausdruckskraft: List comprehensions teilen um ein Pivot, dann sortiert man beide Teile rekursiv. Nicht der effizienteste Quicksort, aber eine schöne Demonstration von Rekursion und Comprehensions.
-- elegant but not in-place quicksort
qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (p:xs) =
qsort smaller ++ [p] ++ qsort larger
where
smaller = [x | x <- xs, x < p]
larger = [x | x <- xs, x >= p]
> qsort [3,1,4,1,5,9,2,6]
[1,1,2,3,4,5,6,9]Gegenseitige Rekursion
Gegenseitige Rekursion heißt, zwei oder mehr Funktionen rufen sich gegenseitig auf. Hier nähern sich even' und odd' dem Basisfall 0. Beide müssen definiert sein (in einem Modul spielt die Reihenfolge keine Rolle).
-- functions calling each other
even' :: Int -> Bool
even' 0 = True
even' n = odd' (n - 1)
odd' :: Int -> Bool
odd' 0 = False
odd' n = even' (n - 1)
> even' 4
TrueFunktionen höherer Ordnung
map
map wendet eine Funktion auf jedes Element an
-- map applies a function to every element
> map (*2) [1,2,3]
[2,4,6]
> map (+1) [1..5]
[2,3,4,5,6]
-- with a lambda
> map (\x -> x*x) [1..4]
[1,4,9,16]
-- strings are lists of chars
> map toUpper "hello"
"HELLO"filter
filter behält Elemente, die das Prädikat erfüllen
-- keep elements satisfying a predicate
> filter even [1..10]
[2,4,6,8,10]
> filter (>3) [1,2,3,4,5]
[4,5]
-- with a lambda
> filter (\c -> c /= ' ') "hello world"
"helloworld"
-- count matches
> length (filter odd [1..100])
50foldl und foldr
foldl linke Faltung, foldr rechte Faltung
-- foldl: left fold (function, seed, list)
> foldl (+) 0 [1..5]
15
-- foldr: right fold
> foldr (+) 0 [1..5]
15
-- associativity differs:
-- foldl: ((((0+1)+2)+3)+4)+5
-- foldr: 1+(2+(3+(4+(5+0))))
-- foldl1/foldr1 use the first element as seed
> foldl1 max [3,1,4,1,5]
5zipWith
zipWith kombiniert zwei Listen mit einer Funktion
-- apply a function to paired elements
> zipWith (+) [1,2,3] [10,20,30]
[11,22,33]
> zipWith (*) [1,2,3,4] [2,2,2,2]
[2,4,6,8]
-- combine strings
> zipWith (\a b -> a ++ b) ["a","b"] ["1","2"]
["a1","b2"]
-- stops at the shorter list
> zipWith max [1,5,3] [2,4,6,8]
[2,5,6]Funktionsanwendung $
$ Operator reduziert Klammern
-- scanl returns all intermediate accumulators
> scanl (+) 0 [1,2,3]
[0,1,3,6]
-- scanr from the right
> scanr (+) 0 [1,2,3]
[6,5,3,0]
-- running maximum
> scanl max 0 [3,1,4,1,5]
[0,3,3,4,4,5]takeWhile & dropWhile
takeWhile stoppt am ersten Element, das das Prädikat nicht erfüllt; dropWhile entfernt den Präfix, der es erfüllt. span teilt eine Liste am ersten nicht erfüllenden Element. Ideal für Präfix-basierte Verarbeitung.
-- takeWhile: take while the predicate holds
> takeWhile (<5) [1,2,3,4,5,4,3]
[1,2,3,4]
-- dropWhile: drop while the predicate holds
> dropWhile (<5) [1,2,3,4,5,4,3]
[5,4,3]
-- span splits at the first failing element
> span (<3) [1,2,3,4,5]
([1,2],[3,4,5])
-- first word of a string
> takeWhile (/= ' ') "hello world"
"hello"Map / Filter / Fold
Verkettete Operationen
map/filter/fold kombinieren
-- '\' defines a lambda (resembles the λ symbol)
> (\x -> x + 1) 5
6
-- used with map
> map (\x -> x * x) [1..4]
[1,4,9,16]
-- used with filter
> filter (\x -> x > 2) [1,2,3,4]
[3,4]scanl/scanr
scan behält alle Zwischenergebnisse
-- parameters separated by spaces
> (\x y -> x + y) 3 4
7
-- in zipWith
> zipWith (\x y -> x * y + 1) [1,2,3] [10,20,30]
[11,21,31]takeWhile/dropWhile
Elemente nach Bedingung nehmen/verwerfen
-- lambdas can pattern match their one argument
> map (\(a,b) -> a + b) [(1,2),(3,4)]
[3,7]
-- only ONE pattern, no fallthrough
-- this crashes if it doesn't match:
> (\(x:_) -> x) [] -- runtime errorLambdas in Higher-Order
Lambdas glänzen bei fold, filter und map. Sie können andere Funktionen zurückgeben (\x -> \y -> ...) und demonstrieren so Currying. Kurz halten — lange Lambdas sind als benannte Funktionen klarer.
-- combining with fold
> foldl (\acc x -> acc + x*2) 0 [1,2,3]
12
-- with filter (infix via backticks)
> length . filter (\x -> x `mod` 2 == 0) $ [1..10]
5
-- a lambda returning a function
> (\x -> \y -> x + y) 3 4
7Point-free-Stil
Point-free-Stil lässt explizite Argumente weg und drückt Funktionen über Komposition und Anwendung aus. Knapp, aber bei Übermaß lesbarkeitsschädlich. Für kurze Ketten mit offensichtlichem Fluss bevorzugen.
-- explicit: name every argument
sumSquares xs = sum (map (^2) xs)
-- point-free: omit arguments via composition
sumSquares' = sum . map (^2)
-- more examples
count p = length . filter p
oddNums = filter odd
negateAll = map negateLambdas
Anonyme Funktionen
\ definiert ein Lambda, wie λ
-- all functions are curried (one arg at a time)
add :: Int -> Int -> Int
add x y = x + y
-- apply fewer args to get a function
add5 :: Int -> Int
add5 = add 5
> add5 10
15
-- with map
> map (add 5) [1,2,3]
[6,7,8]Mehrfachparameter-Lambda
Mehrere Parameter durch Leerzeichen getrennt
-- left section (fix the left operand)
> map (+3) [1,2,3]
[4,5,6]
-- right section (fix the right operand)
> map (3/) [9, 12, 18]
[0.333..,0.25,0.166..]
-- (-3) is the NUMBER, not a section!
> map (subtract 3) [4,5,6]
[1,2,3]
-- comparison sections
> filter (>3) [1..6]
[4,5,6]Lambda mit Musterabgleich
Musterabgleich in Lambdas
-- flip swaps the first two arguments
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
-- fix the second argument instead of the first
> map (flip (-) 1) [3,4,5]
[2,3,4]
-- divide from the other side
> map (flip div 2) [4,6,9]
[2,3,4]Currying erklärt
a -> b -> c bedeutet a -> (b -> c): eine Funktion, die 'a' nimmt und eine Funktion zurückgibt. Anwendung ist links-assoziativ: f x y = (f x) y. Deshalb funktioniert partielle Anwendung ganz natürlich.
-- this signature:
max :: Int -> Int -> Int
-- is actually: Int -> (Int -> Int)
-- max takes an Int and returns a function
-- step by step
> :t max 5
max 5 :: Int -> Int
> (max 5) 10
10
-- application is left-associative
> max 5 10 == ((max 5) 10)
TrueFunktionen, die Funktionen zurückgeben
Funktionen können andere Funktionen zurückgeben — eine natürliche Folge des Curryings. Das ermöglicht Funktions-Fabriken: multiplyBy 2 erzeugt einen Verdoppler. Partielle Anwendung wie greet "Hi" konfiguriert eine Funktion für spätere Nutzung.
-- return a function
multiplyBy :: Int -> (Int -> Int)
multiplyBy n = \x -> n * x
-- or equivalently (currying)
multiplyBy' n x = n * x
> let double = multiplyBy 2
> double 21
42
-- configure a function via partial application
greet :: String -> String -> String
greet greeting name = greeting ++ ", " ++ name
sayHi = greet "Hi" -- a configured greeterCurrying
Partielle Anwendung
Alle Funktionen werden automatisch gecurried
-- Eq: equality
> 5 == 5
True
> "a" /= "b"
True
-- Ord: ordering
> 3 < 5
True
> compare 3 5
LT
-- Show: convert to a string
> show 5
"5"
> show [1,2,3]
"[1,2,3]"
-- Read: parse from a string
> read "5" + 2
7Infix-Partielle Anwendung
Partielle Anwendung von Operatoren
-- '=>' constrains the type variables
(==) :: Eq a => a -> a -> Bool
(<) :: Ord a => a -> a -> Bool
show :: Show a => a -> String
-- a function requiring Eq
elem :: Eq a => a -> [a] -> Bool
elem _ [] = False
elem x (y:ys) = x == y || elem x ys
-- multiple constraints
showMax :: (Ord a, Show a) => [a] -> String
showMax xs = show (maximum xs)flip-Funktion
flip tauscht die Argumentreihenfolge
-- declare a typeclass with method signatures
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
-- default implementations
x == y = not (x /= y)
x /= y = not (x == y)
-- minimal: define either (==) or (/=)Instanz-Deklarationen
instance Typeclass Type where implementiert eine Typeclass für einen Typ. Jede Methode muss definiert sein, außer es gibt einen Default. Danach können TrafficLight-Werte ==, /= und show nutzen.
data TrafficLight = Red | Yellow | Green
instance Eq TrafficLight where
Red == Red = True
Yellow == Yellow = True
Green == Green = True
_ == _ = False
instance Show TrafficLight where
show Red = "Red light"
show Yellow = "Yellow light"
show Green = "Green light"Numerische Typeclasses
Die numerische Hierarchie umfasst Num (alle Zahlen), Fractional (unterstützt /) und Integral (unterstützt div, mod). Int und Double sind verschiedene Typen — mit fromIntegral sicher umwandeln.
-- Num: basic numeric operations
(+) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
-- Fractional: supports division
(/) :: Fractional a => a -> a -> a
-- Integral: integer division
div, mod :: Integral a => a -> a -> a
-- convert between numeric types
> fromIntegral (length [1,2,3]) + 0.5
3.5Deriving
Viele Typeclasses lassen sich automatisch ableiten: Eq, Ord, Show, Read, Enum, Bounded. Das erspart Boilerplate-Instanzen. Enum und Bounded ermöglichen Bereichs-Syntax ([Red ..]) und minBound/maxBound.
-- automatically derive common typeclasses
data Color = Red | Green | Blue
deriving (Eq, Ord, Show, Read, Enum, Bounded)
> show Red
"Red"
> Red < Green
True
> minBound :: Color
Red
> [Red ..]
[Red,Green,Blue]Komposition
Funktionskomposition
. komponiert von rechts nach links
-- sum type: alternatives separated by '|'
data Bool' = False' | True'
-- pattern match on constructors
not' :: Bool' -> Bool'
not' True' = False'
not' False' = True'
-- value constructors with no fields
data Weekday = Mon | Tue | Wed | Thu | FriMehrfunktions-Komposition
Mehrere Funktionen verketten-komponieren
-- product type: constructors carry fields
data Point = Point Double Double
data Shape
= Circle Double -- radius
| Rect Double Double -- width, height
-- construct values
p = Point 1.0 2.0
c = Circle 5.0
r = Rect 3.0 4.0Point-free-Stil
Argumente weglassen, prägnanter
-- a type parameter 'a' (like Maybe)
data Maybe' a = Nothing' | Just' a
-- a boxed value
data Box a = Box a
-- use it with any type
> Just' 5
Just' 5
> Box "hello"
Box "hello"
-- model failure with Maybe
divide :: Double -> Double -> Maybe' Double
divide _ 0 = Nothing'
divide x y = Just' (x/y)Rekursive Typen
Ein Typ kann sich selbst referenzieren und rekursive Strukturen formen. IntList ist eine einfach verkettete Liste von Ints. Tree a ist ein Binärbaum. Pattern Matching rekursiert natürlich über solche Strukturen.
-- a custom linked list
data IntList = INil | ICons Int IntList
-- build the list 1,2,3
xs = ICons 1 (ICons 2 (ICons 3 INil))
-- a binary tree
data Tree a = Leaf | Node a (Tree a) (Tree a)
tree = Node 1 (Node 2 Leaf Leaf) (Node 3 Leaf Leaf)Ein BST mit Funktionen
Algebraische Datentypen paaren sich natürlich mit rekursiven Funktionen via Pattern Matching. Diese BST-Implementierung fügt ein und hält die Ordnung, und die Inorder-Durchquerung glättet zu einer sortierten Liste. ADTs plus Rekursion ersetzen Klassen der OOP.
data Tree a = Leaf | Node a (Tree a) (Tree a)
-- insert into a binary search tree
insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node x Leaf Leaf
insert x (Node y l r)
| x < y = Node y (insert x l) r
| otherwise = Node y l (insert x r)
-- inorder traversal yields a sorted list
inorder :: Tree a -> [a]
inorder Leaf = []
inorder (Node x l r) = inorder l ++ [x] ++ inorder rAufzählungen
Ein Summentyp aus nullären Konstruktoren wirkt wie ein Enum. Deriving Enum ermöglicht succ/pred und Bereichs-Syntax ([North ..]); deriving Bounded liefert minBound/maxBound. Haskell's idiomatiche Aufzählung.
-- enum-like sum type
data Direction = North | East | South | West
deriving (Eq, Ord, Enum, Bounded, Show)
-- enumerate via Enum
> [North .. West]
[North,East,South,West]
-- Bounded: the limits
> minBound :: Direction
North
> maxBound :: Direction
West
-- cycle through directions
next :: Direction -> Direction
next West = North
next d = succ dMonaden
Maybe-Monade
Maybe behandelt automatisch Fehlerweitergabe
-- without records (positional, error-prone)
data Person0 = Person0 String Int String
-- with records (named fields)
data Person = Person
{ name :: String
, age :: Int
, city :: String
}
-- construct with field names (any order)
p1 = Person { name = "Alice", age = 30, city = "NYC" }Listen-Monade
Listen-Monade repräsentiert nichtdeterministische Berechnung
-- field names are accessor functions
> name p1
"Alice"
> age p1
30
-- their types
> :t name
name :: Person -> String
> :t age
age :: Person -> Int
-- record patterns also work
greet :: Person -> String
greet (Person { name = n }) = "Hi, " ++ nIO-Monade
IO-Monade isoliert Seiteneffekte
-- functional update: change only some fields
p2 = p1 { age = 31 }
-- the original is unchanged (immutable)
> age p1
30
> age p2
31
-- update multiple fields at once
p3 = p1 { age = 31, city = "LA" }bind-Operator
>>= ist die Kern-Monaden-Operation
-- match and bind fields by name
birthday :: Person -> Person
birthday p@Person { age = a } = p { age = a + 1 }
-- ignore unneeded fields
getName :: Person -> String
getName Person { name = n } = n
-- as-pattern keeps the whole record
isAdult :: Person -> Bool
isAdult p@Person { age = a } = a >= 18return
return bringt einen Wert in einen Monaden-Kontext
-- field names share a top-level namespace
data Person = Person { name :: String }
data Company = Company { name :: String }
-- ERROR: 'name' clashes in the same module
-- workaround 1: prefix the fields
data Person' = Person' { personName :: String }
data Company' = Company' { companyName :: String }
-- workaround 2: language extensions
{-# LANGUAGE DuplicateRecordFields #-}Funktoren
fmap
fmap wendet eine Funktion auf einen Wert in einem Funktor an
-- file Geometry.hs
module Geometry
( sphereVolume -- explicit export list
, cubeVolume
) where
sphereVolume :: Float -> Float
sphereVolume r = (4/3) * pi * r^3
cubeVolume :: Float -> Float
cubeVolume s = s^3
-- a helper not in the export list is private
privateHelper = ...<$>-Operator
<$> ist äquivalent zu fmap
-- import everything from Data.List
import Data.List
-- names are now in scope
> sort [3,1,2]
[1,2,3]
> nub [1,1,2,2,3]
[1,2,3]
-- import specific functions
import Data.Maybe (fromMaybe)
-- qualified: use the full module name
import qualified Data.Map as M
> M.emptyFunktions-Funktor
fmap auf Funktionen ist .
-- import only specific names
import Data.List (sort, nub, group)
-- import everything except some
import Data.List hiding (head, tail)
-- import a type without its constructors
import Data.Tree (Tree, Node)
-- import constructors too
import Data.Tree (Tree(..))Qualifizierte Imports
Qualifizierte Imports erzwingen das Modul-Präfix und verhindern Kollisionen (z. B. Predules filter vs. Data.Map's). import qualified M as M ist idiomatisch. Qualifiziert für Module mit vielen überlappenden Namen.
-- avoid name clashes with qualified
import qualified Data.Map as Map
import qualified Data.Set as Set
m = Map.empty
s = Set.fromList [1,2,3]
-- Prelude's filter vs Data.Map's
> filter even [1..6]
[2,4,6]
> Map.filter (>2) (Map.fromList [(1,'a'),(3,'b')])
fromList [(3,'b')]Prelude
Prelude ist der Default-Import und liefert häufige Funktionen und Typen. Einträge mit hiding ausblenden, um Kollisionen zu vermeiden oder bessere Alternativen zu nutzen (z. B. foldl' aus Data.List). Viele Projekte nutzen eigene Preludes.
-- Prelude is imported by default
-- provides: map, filter, length, (+), etc.
-- hide entries to avoid clashes
import Prelude hiding (head, tail, foldl)
-- use better alternatives
import Data.List (foldl') -- strict fold
-- common standard modules
import Data.List
import Data.Maybe
import Data.Char
import Data.EitherModul-Hierarchie
Modulnamen sind hierarchisch und spiegeln die Verzeichnisstruktur: A.B.C liegt in A/B/C.hs. Ein Modul kann ein anderes mit 'module M' in seiner Export-Liste re-exportieren — praktisch, um eine öffentliche API zu bündeln.
-- hierarchical names mirror directories
-- module Data.Geometry.Sphere where
-- lives in: Data/Geometry/Sphere.hs
-- import nested modules
import Data.Geometry.Sphere
import Data.Geometry.Cube
-- re-export a whole module
module MyMod
( module Data.List -- re-export
, myFunc
) where
import Data.List
myFunc = sortApplicatives
<*>-Operator
<*> wendet eine Funktion in einem Funktor an
-- IO actions produce effects when run
greet :: IO ()
greet = do
putStrLn "What's your name?"
name <- getLine
putStrLn ("Hello, " ++ name)
-- run in GHCi
> greet
What's your name?
Alice
Hello, AliceReine Funktionsanwendung
pure bringt einen Wert in ein Applicative
-- every program starts in main
main :: IO ()
main = putStrLn "Hello, World!"
-- combine actions with do
main = do
greet
putStrLn "Done."
-- command-line arguments
import System.Environment
main = do
args <- getArgs
print argsListen-Applicative
List <*> ist ein kartesisches Produkt
-- do is sugar for sequential actions
echo = do
s <- getLine
putStrLn s
-- desugars to bind (>>=)
echo' = getLine >>= putStrLn
-- 'let' needs no 'in' inside do
greet = do
let msg = "Hi!"
putStrLn msgEingabe-Funktionen
getLine liest eine Zeile (ohne Umbruch), getChar ein einzelnes Zeichen, getContents lazy die gesamte stdin. Ergebnisse mit '<-' binden. getContents ist lazy — ideal für Streaming-Pipelines.
-- read a line (without the newline)
> line <- getLine
hello world
> line
"hello world"
-- read a single character
> c <- getChar
a> c
'a'
-- read all of stdin lazily
process = do
text <- getContents
putStr (map toUpper text)Ausgabe-Funktionen
putStrLn und putStr schreiben einen String nach stdout, mit/ohne Zeilenumbruch. print entspricht putStrLn . show, fügt also Anführungszeichen um Strings. Je nach Umbruchbedarf und ob der Wert ein String ist wählen.
-- with a trailing newline
putStrLn :: String -> IO ()
-- without a newline
putStr :: String -> IO ()
-- any Show-able value
print :: Show a => a -> IO ()
> putStrLn "hi" -- hi
> putStr "hi" -- hi (no newline)
> print 5 -- 5
> print "hi" -- "hi" (with quotes)Datei-IO
readFile liest lazy, writeFile überschreibt, appendFile hängt ans Ende. bracket verwenden, damit Ressourcen bei Ausnahmen geschlossen werden. Dateien werden über FilePath adressiert (ein Alias für String).
-- read a whole file (lazy)
readFile :: FilePath -> IO String
-- write a file (overwrites)
writeFile :: FilePath -> String -> IO ()
-- append to a file
appendFile :: FilePath -> String -> IO ()
main = do
contents <- readFile "input.txt"
writeFile "output.txt" (map toUpper contents)
-- safe resource handling
import Control.Exception (bracket)IO
Grundlegende IO
IO-Operationen sind in der IO-Monade
-- Functor: a context you can map over
class Functor f where
fmap :: (a -> b) -> f a -> f b
-- '<$>' is fmap as an operator
> fmap (+1) (Just 5)
Just 6
> (+1) <$> Just 5
Just 6
> (+1) <$> Nothing
Nothing
> map (+1) [1,2,3] -- map is fmap for lists
[2,3,4]Dateien Lesen/Schreiben
readFile/writeFile behandeln Dateien
-- Applicative: functions inside a context
class Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
-- apply a wrapped function
> pure (+) <*> Just 3 <*> Just 4
Just 7
> Just (+1) <*> Just 5
Just 6
-- for lists, <*> is the Cartesian product
> [(+1), (*2)] <*> [1,2,3]
[2,3,4,2,4,6]putStr/putChar
Verschiedene Ausgabefunktionen
-- Monad: sequential, dependent computations
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b -- bind
-- bind chains dependent computations
> Just 3 >>= \x -> Just (x+1)
Just 4
> Nothing >>= \x -> Just (x+1)
Nothing
-- '>>' ignores the left result
> putStrLn "a" >> putStrLn "b"
a
bInteraktion
getLine liest eine Eingabezeile
-- do notation
greet = do
name <- getLine
putStrLn ("Hi " ++ name)
-- desugars to bind
greet' = getLine >>= \name ->
putStrLn ("Hi " ++ name)
-- 'let' becomes a regular binding
compute = do
let x = 5
print (x * x)
-- desugars to:
compute' = let x = 5 in print (x*x)Maybe-Monaden-Kette
Maybes Monade schließt kurz: gibt ein Schritt Nothing zurück, ist die ganze Berechnung Nothing ohne weitere Arbeit. do versteckt die manuellen Nothing-Checks und macht Fehlerpropagation automatisch und sauber.
-- short-circuit on Nothing
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- chain with do (auto-propagates failure)
calc = do
a <- safeDiv 10 2
b <- safeDiv a 2
return (b + 1)
> calc
Just 3.5
-- any Nothing stops the whole chain
> safeDiv 10 0 >>= \a -> safeDiv a 2
NothingListen-Monade
Die Listen-Monade modelliert Nicht-Determinismus: jedes Binden erkundet alle Möglichkeiten und erzeugt das kartesische Produkt. do über Listen entspricht List comprehensions. Das vereinheitlicht Comprehension- und Monaden-Stil.
-- list bind = non-deterministic computation
> [1,2] >>= \x -> [x, x*10]
[1,10,2,20]
-- do over lists == list comprehension
pairs = do
x <- [1,2]
y <- ['a','b']
return (x, y)
> pairs
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- equivalent comprehension
> [(x,y) | x <- [1,2], y <- ['a','b']]Do-Notation
Grundlegendes do
do-Syntaxzucker vereinfacht Monaden-Operationen
-- 'type' creates a synonym (not a new type)
type String = [Char]
type PhoneNumber = String
type Name = String
-- improves readability of signatures
printEntry :: Name -> PhoneNumber -> IO ()
printEntry name num = putStrLn (name ++ ": " ++ num)let in do
let in do benötigt kein in
-- newtype: one constructor, one field, zero cost
newtype Dollars = Dollars Double
newtype Count = Count Int
-- pattern match or unwrap the field
addDollars :: Dollars -> Dollars -> Dollars
addDollars (Dollars a) (Dollars b) = Dollars (a + b)
-- distinct type: can't mix with raw Double
total :: Dollars
total = addDollars (Dollars 10) (Dollars 20)do-Desugaring
do ist syntaktischer Zucker für >>=
-- type: just a synonym (no new type, no safety)
type Score = Int
-- newtype: distinct type, zero cost, one field
newtype Score' = Score' Int
-- data: full ADT, runtime cost,
-- can have multiple constructors/fields
data Score'' = Score'' Int | Bonus Int
-- newtype is strict: exactly one
-- constructor and one field, but a distinct typenewtype für neue Instanzen
newtype erlaubt, demselben zugrunde liegenden Typ verschiedene Typeclass-Instanzen zu geben. Sum und Product umwickeln dieselbe Zahl, haben aber verschiedene Monoid-Instanzen (Addition vs. Multiplikation). Ein übliches, mächtiges Muster.
-- wrap to attach different typeclass instances
newtype Sum a = Sum { getSum :: a }
instance Num a => Monoid (Sum a) where
mempty = Sum 0
Sum a `mappend` Sum b = Sum (a + b)
newtype Product a = Product { getProduct :: a }
-- different Monoid: multiplication
-- same underlying type, different behavior
> getSum (Sum 3 <> Sum 4)
7
> getProduct (Product 3 <> Product 4)
12Parametrisierte Synonyme
Typ-Synonyme können Parameter nehmen und wirken als leichtgewichtige Abstraktionen. AssocList k v ist [(k,v)] und macht Signaturen selbstdokumentierend. Für Klarheit nutzen, aber bedenken: es sind nur Aliase ohne Typsicherheit.
-- type synonyms can take parameters
type AssocList k v = [(k, v)]
-- used in signatures (self-documenting)
lookup :: Eq k => k -> AssocList k v -> Maybe v
lookup _ [] = Nothing
lookup k ((k',v):rest)
| k == k' = Just v
| otherwise = lookup k rest
-- more examples
type Parser a = String -> Maybe (a, String)
type Matrix a = [[a]]Verwandte Haskell-Snippets
Copy-paste ready code for common tasks.
Typen und Typklassen
Algebraische Datentypen und Typklassen definieren.
Maybe- und IO-Monaden
Maybe für Sicherheit und IO für Seiteneffekte verwenden.
List Comprehensions und Laziness
Listen mit Comprehensions generieren und Laziness nutzen.
Funktoren, Applicatives, Monad-Typklassen
Die drei zentralen Abstraktions-Typklassen.
IO und do-Notation
Programmierung mit Seiteneffekten in Haskell.
Module und Imports
Code mit Modulen organisieren und Exports kontrollieren.
Laziness und Striktheit
Lazye Auswertung verstehen und wann Striktheit nötig ist.
Applicative Funktoren
Funktionen in einem Kontext mit weniger Macht als Monad anwenden.
Was this helpful?