TU Wien:Funktionale Programmierung VU (Knoop)/Wichtige Funktionen und Syntax

Funktionen

Wählt die ersten X element einer Liste aus

take :: Int -> [a] -> [a]

Wählt das X-te Element aus der Liste aus

[a] !! Int -> a

@ splitet ein Datum in seine Elemente auf

• Bsp.: tree@(a b c), so kann ich auf tree, a b unc c zugreifen
• Bsp.: list@(a:b), so kann ich auf head (a), tail (b) und und list zugreifen

Spaltet einen Satz in seine Wörter auf

words :: String -> [String]

Gibt eine Liste in verkehrter Reihenfolge zurück

reverse :: [a] -> [a]

Liefert die Liste ab Element Int+1 zurück

drop :: Int -> [a] -> [a]

Liefert das erste Element der Liste

head :: [a] -> a

Liefert alle Elemente bis auf das erste Element zurück

tail :: [a] -> [a]

Liefert die Länge einer Liste durch

length :: [a] -> Int

Liefert die Summe aller Nummern in der Liste

sum :: [Num] -> Num

Liefert das Produkt aller Nummern in der Liste. Wenn die Liste nur ein Element hat, dann wird dieses Element zurück gegeben

product :: [Num] -> Num

Fügt mehrere Zeichenketten (Zeilen) zu einer Zeichenkette zusammen und fügt nach jeder Zeile ein \n (newline) Symbol ein.

unlines :: [String] -> String

Liefert das Minimum / Maximum der Liste

minimum :: [a] -> a, maximum :: [a] -> a

Erstes Element eines Tupels

fst :: (a,b) -> a

Zweites Element eines Tupels

snd :: (a,b) -> b

foldl geht die Liste [b] an Elementen durch und wendet immer die Funktion (a -> b -> a) auf a an und ersetzt a mit dem Resultat. Bsp.: foldl (/) 64 [2,4] macht: ((64 / 2) / 4) => 8

foldl :: (a -> b -> a) -> a -> [b] -> a

Funktioniert gleich wie foldl, nur spiegelverkehrt.

• Bsp.: foldr (/) 64 [2,4] macht: (2 / (4 / 64)) => 32

foldr :: (a -> b -> a) -> a -> [b] -> a

Modulo Funktion

a `mod` b == mod a b

Liefert True, wenn die Funktion (a -> Bool) für alle Elemente der Liste True ergibt. 

all :: (a -> Bool) -> [a] -> Bool

Fügt immer ein Element von links mit einem von rechts zu einem Tupel zusammen. Wenn eine Liste länger ist, werden die überstehenden Elemente weggelassen. Bsp.: zip [1,2,3] [4,5] -> [(1,4), (2,5)].

zip :: [a] -> [b] -> [(a,b)]

Fügt Elemente aus mehreren Listen zusammen

• Bsp.: [[1,2], [3,4]] => [1, 2, 3, 4]

concat :: a -> [a]

Angewendet auf die eine Liste geht filter alle Elemente durch und gibt nur die zurück, bei denen die Funktion (a -> Bool) True liefert.

filter :: (a -> Bool) -> [a] -> [a]

Ähnlich wie filter, wird auf eine Liste angewendet und wendet die Funktion (a -> b) auf alle Elemente an. Gibt eine Liste mit den Ergebnisen zurück.

• Bsp.: map (\a == a*2) [1,2] => [2,4]

map :: (a -> b) [a] -> [b]

Wendet die Funktion (a -> [b]) auf die Liste [a] an und liefert die konkatinierte Liste der Funktionsergebnisse zurück.

• Bsp.: concatMap (\x -> [x]) [1,2] == [1,2]
• Bsp.: concatMap (\x -> [x, x*2]) [1,2] == [1,2,2,4]

concatMap :: (a -> [b]) -> [a] -> [b]

Erstellt eine currying Funktion (f :: a -> b -> c) aus einer uncorrying Funktion (g :: (a, b) -> c)

• Bsp.: curry fst 2 3 == 2, fst (2,3) == 2

curry :: ((a,b) -> c) -> a -> b -> c

Macht genau das Gegenteil

• Bsp.: uncurry mod (5,4) == 1, mod 5 4 == 1

uncurry :: (a -> b -> c) -> (a,b) -> c

Iterieren

Läuft von 0 bis 10 und liefert alle Elemente, auf denen i % 2 == 0 zutrifft

[ i | i <- [0..10], i % 2 == 0]

Läuft alle Elemente von l durch und liefert alle Elemente, auf die f zutrifft

[ i | i <- l, (f i) ]

let in

ergibt 10, da x 5 ist

( 
  let x = 5 
  in ( x * 2) 
)

inline if else then

foo = (if x > 5 then True else False)

Datentypen

Polymorpher DatenType

data MyTree a = Nil
            | Node a (MyTree a) (MyTree a)

Nicht polymorpher DatenType

data MyTree = Nil
            | Node MyTree MyTree

TypeKlassen

TypeClass SymClass erstellen

 class SymClass a where
   sym :: a -> a -> Bool

MyTree soll ein Type der TypeClass SymClass sein

instance SymClass (MyTree a) where
  sym Nil Nil = True
  sym (Node Nil Nil) (Node Nil Nil) = False

MyTree soll ein Type der TypeClass SymClass sein, a ist ein type von Eq.

instance Eq a => SymClass (MyTree a) where
  sym Nil Nil = True
  sym (Node Nil Nil) (Node Nil Nil) = False  

Filter Funktion

Definiert die Funktion fname, die eine Funktion (a -> Bool) und einen MyTree übergeben bekommt, und eine Liste aller Elemente zurück liefert, für die die Funktion True zurück gibt.

fname :: (a -> Bool) -> (MyTree a) -> [a]
fname f Nil = []
fname f (Node Nil Nil) = []
...