TU Wien:Funktionale Programmierung VU (Knoop)/Wichtige Funktionen und Syntax
Funktionen[Bearbeiten | Quelltext bearbeiten]
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[Bearbeiten | Quelltext bearbeiten]
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[Bearbeiten | Quelltext bearbeiten]
ergibt 10, da x 5 ist
( let x = 5 in ( x * 2) )
inline if else then[Bearbeiten | Quelltext bearbeiten]
foo = (if x > 5 then True else False)
Datentypen[Bearbeiten | Quelltext bearbeiten]
Polymorpher DatenType
data MyTree a = Nil | Node a (MyTree a) (MyTree a)
Nicht polymorpher DatenType
data MyTree = Nil | Node MyTree MyTree
TypeKlassen[Bearbeiten | Quelltext bearbeiten]
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[Bearbeiten | Quelltext bearbeiten]
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) = [] ...