1
[ 1, 2, 3 ]
2

3
[ 1, 'ab' ]

1
{ 2*x | x e N, x ≤ 10 }
2

3
[2x | x <- [1, 10], x ≤ 20]

1
ghci> [1,2,3] ++ [4,5]
2
[1,2,3,4,5]
3

4
ghci> head [1,2,3]
5
1
6

7
ghci> tail [1,2,3]
8
[2,3]
9

10
ghci> 4 : [1,2,3]
11
[4,1,2,3]
12

13
ghci> [1 .. 10]
14
[1,2,3,4,5,6,7,8,9,10]
15

16
ghci> [1,3 .. 10]
17
[1,3,5,7,9]

1
f x y = x + y + 3
2
f :: Int -> Int -> Int
3
-- :: is of type
4
-- the first Int is for x
5
-- the second Int is for y
6
-- the last Int is for the result

1
import Data.List (group)
2

3
-- doubleReverse: abcd -> abcddcba
4
doubleReverse :: [a] -> [a]
5
doubleReverse x = x ++ reverse x
6

7
-- compr: Kompression "aaabbbcccca" -> [(3,'a'), (3,'b'), (4,'c'), (1,'a')]
8
compr :: Eq a => [a] -> [(a, Int)]
9
compr = map (\y -> (head y, length y)) . group
10

11
-- ggt: Größter gemeinsamer Teiler
12
ggt :: Integer -> Integer -> Integer
13
ggt a 0 = a
14
ggt a b = ggt b (a `mod` b)
15

16
factors :: Integer -> [Integer]
17
factors n = [x | x <- [2 .. n - 1], n `mod` x == 0]
18

19
-- filterAdjacent: Filter einer Liste, wobei Element nur erhalten bleibt, wenn ident mit nachfolgendem, "abbbccd" -> "bbc"
20
filterAdjacent :: Eq a => [a] -> [a]
21
filterAdjacent = (init =<<) . group
22

23
-- isPal: Test auf Palindrom (Variante ohne Verwendung von reverse)
24
isPal :: Eq a => [a] -> Bool
25
isPal x = x == reverse x
26
isPal' x = x == foldl (flip ( : )) [] x
27

28
-- isPrime: Test auf Primzahl
29
isPrime :: Integer -> Bool
30
isPrime n = n > 1 && null (factors n)
31

32
-- isPowOfTwo: Test ob Zahl Potenz von 2 ist.
33
isPowOfTwo :: Integer -> Bool
34
isPowOfTwo 1 = True
35
isPowOfTwo x
36
    | x < 1 = False
37
    | (x `mod` 2) /= 0 = False
38
    | x >= 2 = isPowOfTwo (x `div` 2)
39

40
-- kgv: Kleinstes gemeinsames Vielfaches
41
kgv :: Integer -> Integer -> Integer
42
kgv _ 0 = 0
43
kgv 0 _ = 0
44
kgv x y = abs ((x `quot` gcd x y) * y)
45

46
-- listPrime: Zwei Zahlen als Eingabe, alle Primzahlen dazwischen als Ausgabe
47
listPrime :: Integer -> Integer -> [Integer]
48
listPrime l u = [x | x <- [l .. u], isPrime x]
49

50
-- primFaktorZerlegung: Ausgabe Liste von Tupel mit (Faktor, Anzahl), 144 -> [(2,4),(3,2)]
51
primFaktorZerlegung :: Integer -> [(Integer, Int)]
52
primFaktorZerlegung = compr . primeFactors
53

54
primeFactors n =
55
    case factor of
56
        [] -> [n]
57
        [f] -> factor ++ primeFactors (n `div` f)
58
    where factor = take 1 $ factors n
59

60
-- sums: [Int] -> [Int], n-te Zahl der Ausgabe = Summe der letzten n Zahlen der (endlichen) Eingabe, [1..5] -> [5,9,12,14,15]
61
sums :: [Integer] -> [Integer]
62
sums = scanl1 (+) . reverse

1
import Data.Map
2

3
import Data.Map as M
4
ghci> M.map
5

6
import qualified Data.Map as M

1
ghci> div 3 2
2
1
3
ghci> 3 'div' 2
4
1
5
ghci> (div) 3 2
6
1

1
ghci> f x = 2*x
2
ghci> :type f -- :t or :type
3
f :: Num a => a -> a

1
ghci> f x = if x > 2 then ">2" else "<=2"
2
ghci> :t f
3
f :: (Ord a, Num a) => a -> String

1
ghci> f x = 2*x
2
ghci> f (if (f 2) > 3 then 1 else 3)
3
2
4
ghci> f 1
5
2

1
ghci> :t (!!)
2
(!!) :: [a] -> Int -> a
3
ghci> (!!) [5,2,7] 0
4
5
5
ghci> (!!) [5,2,7] 2
6
7

1
ghci> compare 3 2
2
GT -- Greater Than
3

4
ghci> compare 2 2
5
EQ -- Equal
6

7
ghci> compare 1 2
8
LT -- Lesser Than

1
add :: Int -> Int -> Int
2
add x y = x + y

1
ghci> maxBound
2
()
3

4
ghci> maxBound :: Int
5
9223372036854775807
6

7
ghci> maxBound :: Char
8
'\1114111'
9

10
ghci> maxBound :: Ordering
11
GT

1
ghci> show 3
2
"3"
3

4
ghci> show [3]
5
"[3]"
6

7
ghci> show ['a', 'b']
8
"\"ab\""
9

10
ghci> putStrLn $ show "ab"
11
"ab"

1
ghci> :t read
2
read :: Read a => String -> a
3

4
ghci> read "3"
5
*** Exception: Prelude.read: no parse -- Wirft exception, weil nicht weiß welcher Datentyp es werden soll.
6

7
ghci> read "3" :: Int
8
3
9

10
ghci> read "True" :: Bool
11
True

1
ghci> :t map
2
map :: (a -> b) -> [a] -> [b]
3

4
ghci> map show [1,2,3]
5
["1", "2", "3"]
6

7
ghci> map (const 1) [1,2,3]
8
[1,1,1]
9

10
ghci> f x = x + 1
11

12
ghci> map f [1,2,3]
13
[2,3,4]
14

15
ghci> map (\x -> x * 2 + 1) [1,3,5]
16
[3,7,11]

1
ghci> mymap f xs = foldr (\x acc -> f x : acc) [] xs
2

3
-- Point freestyle
4
ghci> mymap f = foldr ((:) . f) []
5

6
ghci> mymap succ [1,2,3]

1
ghci> :t filter
2
filter :: (a -> Bool) -> [a] -> [a]
3

4
ghci> f x = x < 5
5

6
ghci> filter f [1 .. 10]
7
[1,2,3,4]

1
-- displays recursive function
2
f 0 = 0
3
f x = 1 + f(x - 1)
4

5
-- shows an sum function with an unknown length list
6
mysum [] = 0
7
mysum (x:xs) = x + mysum xs
8

9
-- ---------------------------------------------------------- --
10
-- own Maximum example with recursive check.
11
mymax x y if x < y then y else x
12

13
mymaximum [] = error "will nicht"
14
mymaximum [x] = x
15
mymaximum (x:xs) = mymax x (mymaximum xs)

1
ghci> :load file.hs
2
[1 of 1] Compiling Main             ( file.hs, interpreted )
3
Ok, one module loaded.
4

5
ghci> mymaximum [2,5,3,6,7,1]
6
7

1
-- Catching Empty Lists
2
myzip [] _ = []
3
myzip _ [] = []
4

5
myzip (x:xs) (y:ys) = (x,y):myzip xs ys

1
f $ x = f x
2

3
ghci> map (+) [1,2,3]
4
[1+,2+,3+]
5

6
ghci> map ($ 1) [1,2,3]
7
[2,3,4]

1
ghci> sum (filter (>10) (map (*2) [2..10]))
2

3
ghci> sum $ filter (>10) $ map (*2) $ [2..10]
4

5
ghci> f => \x -> sum $ filter (>10) $ map (*2) X
6
ghci> f [2..10]
7
80

1
ghci> f = sum . filter (>10) . map (*2)
2
ghci> f [2..10]
3
80

1
ghci> map (\x -> negate (abs x)) [...]
2

3
ghci> map (\x -> negate . abs $ x) [...]
4

5
ghci> map (negate . abs) [...]
6

7
-- ------------------------------------
8
ghci> map (\xs -> negate (sum (tail xs))) [...]
9

10
ghci> map (\xs -> negate . sum(tail xs)) [...]
11

12
ghci> map (\xs -> negate . sum . tail $ xs) [...]
13

14
ghci> map (negate . sum . tail) [...]
15

16
-- ------------------------------------
17
ghci> f = sum (takeWhile (<10000) (filter odd (map (^2) [1..])))
18

19
ghci> f = sum (takeWhile (<10000) (filter odd . map (^2) $ [1..]))
20

21
ghci> f = sum (takeWhile (<10000) . filter odd . map (^2) $ [1..])
22

23
ghci> f = sum . takeWhile (<10000) . filter odd . map (^2) $ [1..]

1
ghci> negate . (* 3) $ 2
2
-6
3
ghci> negate . (* 3) 2
4
-6
5
ghci> negate $ (* 3) $ 2
6
-6
7
ghci> negate ( (* 3) 2 )
8
-6
9
ghci> negate (2* 3)
10
-6

1
myelem x xs = foldl (\acc x -> if ((x==y) || acc) then True else False) False xs

1
ghci> import Data.Char
2
ghci> ord 'a'
3
97
4

5
ghci> chr '65'
6
'A'

1
import Data.Char
2
-- Ascii values 32 >= n < 127
3

4
-- encrypt "ein geheimer satz" 2
5
encrypt :: [Char] -> Int -> String
6
encrypt []  x = []
7
encrypt (x:xs) n = shift x n : encrypt xs n
8

9
-- decrypt "ein verschlüsselter satz" 2
10
decrypt :: [Char] -> Int -> String
11
decrypt x n = encrypt x (negate n)
12

13
-- shift 'a' 2 = 'c'
14
shift :: Char -> Int -> Char
15
shift x n = chr ((ord x + n) `mod` 127) -- 127 weil es 127 ASCII characters gibt
16

17
mapShift n x = chr ((ord x + n) `mod` 127) -- 127 weil es 127 ASCII characters gibt
18

19
mapEncrypt [] n = []
20
mapEncrypt x n = map (mapShift n) x
21
mapDecrypt x n = map (mapShift (negate n)) x

1
-- returns the input text again
2
ghci> getLine >>= putStrLn
3

4
ghci> (getLine >>= putStrLn) >>= \x -> putStrLn "end"
5

6
-- getLine selber ohne input
7
ghci> (return "abc" :: IO String) >>= putStrLn >>= \x -> putStrLn "end"
8
abc
9
end
10

11
-- falls typ genutzt wird, der nicht gebraucht wird
12
ghci> putStrLn "hello" >> putStrLn "word"

1
ghci> return "abc" :: [String]

1
ghci> :t (\x y z -> x)
2
(\x y z -> x) :: p1 -> p2 -> p3 -> p1

1
ghci> import Data.List
2
ghci> let values = [-4.3,-2.4,-1.2,0.4,2.3,5.9,10.5,29.1,5.3,-2.4,-14.5,2.9,2.3]
3
ghci> groupBy (\x y -> ((x >= 0) && (y >= 0)) || ((x < 0) && (y < 0))) values
4
[[-4.3,-2.4,-1.2],[0.4,2.3,5.9,10.5,29.1,5.3],[-2.4,-14.5],[2.9,2.3]]
5

6
-- vereinfachung
7
ghci> groupBy (\x y -> ((x >= 0) == (y >= 0))) values
8
[[-4.3,-2.4,-1.2],[0.4,2.3,5.9,10.5,29.1,5.3],[-2.4,-14.5],[2.9,2.3]]
9

10
-- vereinfachung mit on
11
ghci> import Data.Functions
12
ghci> groupBy ((==) on (>=0)) values
13
[[-4.3,-2.4,-1.2],[0.4,2.3,5.9,10.5,29.1,5.3],[-2.4,-14.5],[2.9,2.3]]

1
import Network.Simple.TCP (connect, send, recv)
2
import qualified Data.ByteString as BS
3
import System.IO (hFlush, stdout)
4

5
main = do
6
    putStr "Domain name: "
7
    hFlush stdout --durch puffern kann der string vllt erst nach getline ausgegeben werden
8
    domain <- BS.getLine -- returnt bytestring
9
    connect "whois.nic.at" "43" $ \(socket, _) -> do
10
        send socket domain
11
        mbs <- recv socket 4096
12
        case mbs of
13
            Nothing -> return()
14
            Just bs -> BS.putStrLn bs