Info SPLib Funktionen

SPLib.Basic

if'
 Bool -> a -> a -> a
x y z gibt y zurück, falls x wahr ist, ansonsten z
id
 a -> a
x x (Identität)
show
 a -> String
x wandelt x in einen String um
read
 String -> a
x wandelt String x in entsprechenden Wert von Typ a um.
Der Rückgabetyp muss explizit angegeben werden, z.B. (read "[1,2,3]")::[Int]
trace
 String -> a -> a
x y gibt x auf der Konsole (stderr) aus und gibt y zurück
++
 [a] -> [a] -> [a]
lst1 lst2 hängt lst2 an lst1 an, z.B. [1,2]++[3,4] = [1,2,3,4]
.
 (b -> c) -> (a -> b) -> (a -> c)
f g die Funktion, welche x auf (f (g x)) abbildet (Komposition)

fst
 (a,b) -> a
(x,y) x (erster Wert eines Tupels)
snd
 (a,b) -> b
(x,y) y (zweiter Wert eines Tupels)

&&
 Bool -> Bool -> Bool
a b a && b (Konjunktion)
||
 Bool -> Bool -> Bool
a b a || b (Disjunktion)
not
 Bool -> Bool
a Negation von a

==
 a -> a -> Bool
x y x == y (Gleichheit)
/=
 a -> a -> Bool
x y x /= y (Ungleichheit)
<
 a -> a -> Bool
x y x < y
<=
 a -> a -> Bool
x y x <= y
>
 a -> a -> Bool
x y x > y
>=
 a -> a -> Bool
x y x >= y

+
 Int -> Int -> Int
a b a + b
-
 Int -> Int -> Int
a b a - b
*
 Int -> Int -> Int
a b a * b
^
 Int -> Int -> Int
a b a ^ b (Potenzieren)
div
 Int -> Int -> Int
a b wie oft b in a passt (ganzzahlige Division)
mod
 Int -> Int -> Int
a b Rest von a geteilt durch b (Modulo)
min
 Int -> Int -> Int
a b gibt a zurück, falls a < b, ansonsten b
max
 Int -> Int -> Int
a b gibt a zurück, falls a > b, ansonsten b
succ
 Int -> Int
x x+1
pred
 Int -> Int
x x-1

SPLib.List

isEmpty
 [a] -> Bool
lst gibt True zurück, falls lst keine Elemente enthält, ansonsten False
length
 [a] -> Int
lst gibt Anzahl der Elemente in lst zurück

get
 Int -> [a] -> a
i lst gibt Element mit Index i in lst zurück; erstes Element hat Index 0
first
 [a] -> a
lst gibt erstes Element in lst zurück
last
 [a] -> a
lst gibt letztes Element in lst zurück

set
 a -> Int -> [a] -> [a]
el i lst setzt Element mit Index i in lst auf den Wert el
prepend
 a -> [a] -> [a]
el lst hängt el vorne an lst an
append
 a -> [a] -> [a]
el lst hängt el hinten an lst an
insert
 a -> Int -> [a] -> [a]
el i lst fügt el in lst ein, sodass es in der neuen Liste Index i hat

remove
 Int -> [a] -> [a]
i lst entfernt Element mit Index i aus lst
removeFirst
 [a] -> [a]
lst entfernt erstes Element aus lst
removeLast
 [a] -> [a]
lst entfernt letztes Element aus lst

take
 Int -> [a] -> [a]
n lst gibt die ersten n Elemente von lst zurück. Falls lst weniger als n Elemente hat, wird die ganze Liste lst zurückgegeben
drop
 Int -> [a] -> [a]
n lst entfernt die ersten n Elemente von lst. Falls lst weniger als n Elemente hat, wird die leere Liste zurückgegeben

reverse
 [a] -> [a]
lst dreht die Reihenfolge der Elemente in lst um
sort
 [a] -> [a]
lst sortiert die Elemente in lst
sortBy
 (a -> a -> Ordering) -> [a] -> [a]
f lst sortiert die Elemente in lst nach der Ordnung, welche durch f beschrieben wird

concat
 [[a]] -> [a]
lst Konkateniert Listen aus lst miteinander, z.B. concat [a,b,c] = a ++ b ++ c
zip
 [a] -> [b] -> [(a,b)]
lst1 lst2 verknüpft die Elemente der beiden Listen paarweise, z.B. zip [1,2,3] ['a','b','c'] = [(1,'a'),(2,'b'),(3,'c')].
Falls eine Liste kürzer ist als die andere, dann werden die überschüssigen Elemente der längeren Liste ignoriert

map
 (a -> b) -> [a] -> [b]
f lst wendet f auf jedes Element von lst an, z.B. map f [1,2,3] = [(f 1), (f 2), (f 3)]
filter
 (a -> Bool) -> [a] -> [a]
f lst entfernt alle Elemente x aus lst, für die (f x) == False
reduce
 (a -> a -> a) -> [a] -> a
f lst angenommen lst=[x1,x2,x3], dann wird (f (f x1 x2) x3) zurückgegeben.
Falls lst aus nur einem Element besteht, wird dieses zurückgegeben. Undefiniert wenn lst leer ist.
foldl
 (b -> a -> b) -> b -> [a] -> b
f acc lst angenommen lst=[x1,x2,x3], dann wird (f (f (f acc x1) x2) x3) zurückgegeben.
Falls lst leer ist, wird acc zurückgegeben
foldr
 (a -> b -> b) -> b -> [a] -> b
f acc lst angenommen lst=[x1,x2,x3], dann wird (f x1 (f x2 (f x3 acc))) zurückgegeben.
Falls lst leer ist, wird acc zurückgegeben
find
 (a -> Bool) -> [a] -> a
f lst gibt das erste Element x aus lst zurück, für welches f x == True gilt. Die Funktion ist undefiniert, falls so ein Element nicht existiert.

SPLib.Map

isEmpty
 (Map k v) -> Bool
m gibt True zurück gdw. m leer ist
size
 (Map k v) -> Int
m gibt Anzahl der Elemente in m zurück

empty
 (Map k v)
gibt eine leere Map zurück
fromList
 [(k,v)] -> (Map k v)
lst wandelt lst in eine Map um. Falls ein Schlüssel mehrfach vorkommt, wird der letzte dazugehörige Wert genommen
toList
 (Map k v) -> [(k,v)]
m wandelt m in eine Liste von Tupeln um

hasKey
 k -> (Map k v) -> Bool
key m gibt True zurück gdw. m den Schlüssel key enthält
get
 k -> (Map k v) -> v
key m gibt den Wert in m mit Schlüssel key zurück. Undefiniert, falls der Schlüssel nicht existiert.
set
 v -> k -> (Map k v) -> (Map k v)
val key m setzt den Wert von Schlüssel key in m auf val
remove
 k -> (Map k v) -> (Map k v)
key m entfernt den Schlüssel key aus m

SPLib.Tree

Hinweis: Ein Knoten v wird durch eine Liste von Int beschrieben (type Path = [Int]), welche den Pfad zu diesem Knoten beschreiben. Beispiele:

allNodes
 (Tree a) -> [Path]
tree gibt Liste aller Knoten von tree zurück
size
 (Tree a) -> Int
tree Anzahl der Knoten in tree
degree
 Path -> (Tree a) -> Int
v tree Anzahl der Kinder von Knoten v in tree
pathExists
 Path -> (Tree a) -> Bool
v tree gibt True zurück gdw. tree einen Knoten mit Pfad v besitzt

getLabel
 Path -> (Tree a) -> a
v tree gibt Beschriftung von Knoten v in tree zurück
setLabel
 a -> Path -> (Tree a) -> (Tree a)
label v tree setzt Beschriftung von Knoten v in tree auf label

rootLabel
 (Tree a) -> a
tree gibt Beschriftung vom Wurzelknoten in tree zurück
rootDegree
 (Tree a) -> Int
tree gibt Anzahl der Kinder vom Wurzelknoten in tree zurück

subtree
 Path -> (Tree a) -> (Tree a)
v tree gibt den Teilbaum von tree, welcher ab Knoten v beginnt
appendSubtree
 (Tree a) -> Path -> (Tree a) -> (Tree a)
subtree v tree hängt den Teilbaum subtree an den Knoten v in tree