Derzeit erarbeite ich mir die Grundlagen der funktionalen Programmiersprache
Standard ML (Studium - Fortgeschrittene Konzepte funktionaler Programmierung). Da ich schon ein bischen
Haskell kann, konnte ich es mir nicht nehmen die Aufgaben auch in einer Haskell-Version zu implementieren. Wie man sieht sind sich SML und Haskell (zumindest bisher in den Grundlagen) sehr ähnlich. Allerdings ist die Syntax von Haskell an einigen Stellen etwas "fortgeschrittener". Es werden in Haskell insgesamt etwas weniger Schlüsselwörter (z.B. val, end, fun, fn...) und Kommas in der Syntax verwendet. Ausserdem gibt es in Haskell die (optionale) Möglichkeit die Typen einer Funktion explizit hinzuschreiben. Was leserlicher ist und zudem Programmierfehler vermeidet. Was ich bisher bei SML vermisse sind auch die sog.
Pattern Guards die es in Haskell gibt. I.A. gefällt mir bisher Haskell besser als SML, u.A. auch da Haskell sich "pur funktional" schimpft während SML auch von imperativen Konzepte explizit Gebrauch macht. Aber soweit bin ich in SML noch nicht. Hier ein paar Funktionen in SML und in Haskell im Vergleich:
Standard ML:
datatype ''a multi
= EMPTY
| ELEM of ''a
| UNION of ''a multi * ''a multi
Haskell:
data (Eq a) => Multi a
= Empty
| Elem a
| Union (Multi a) (Multi a)
deriving Show
Standard ML:
fun number (EMPTY) _ = 0
| number (ELEM x) w = if x = w then 1 else 0
| number (UNION (x,y)) w = (number x w) + (number y w)
fun test_number w =
number (UNION (
EMPTY,
UNION (
ELEM 4,
UNION (
ELEM 6,
UNION (
UNION (
ELEM 4,
ELEM 4
),
EMPTY)
)
)
)) w
Haskell:
number Empty _ = 0
number (Elem x) w = if x == w then 1 else 0
test_number w =
number (Union
Empty
(Union
(Elem 4)
(Union
(Elem 6)
(Union
(Union
(Elem 4)
(Elem 4)
)
Empty)
)
)
) w
Standard ML:
fun simplify (UNION (x,y)) =
let fun is_empty (EMPTY) = true
| is_empty _ = false
val x' = simplify x
val y' = simplify y
in if (is_empty x') andalso (is_empty y')
then EMPTY
else if (is_empty x')
then y'
else if (is_empty y')
then x'
else UNION (x', y')
end
| simplify x = x
Haskell:
simplify (Union x y)
| (isEmpty x') && (isEmpty y') = Empty
| isEmpty x' = y'
| isEmpty y' = x'
| otherwise = Union x' y'
where
isEmpty Empty = True
isEmpty _ = False
x' = simplify x
y' = simplify y
simplify x = x
Standard ML:
fun delete_all m w =
let fun delete_all' (ELEM x) = if x = w then EMPTY else ELEM x
| delete_all' (UNION (x,y)) = UNION (delete_all' x, delete_all' y)
| delete_all' x = x
in simplify (delete_all' m)
end
Haskell:
delete_all m w = simplify (delete_all' m)
where
delete_all' (Elem x) = if x == w then Empty else Elem x
delete_all' (Union x y) = Union (delete_all' x) (delete_all' y)
delete_all' x = x
Standard ML:
fun delete_one m w =
let fun delete_one' (UNION (x,y)) =
let val (x', deleted) = delete_one' x
in if deleted
then (UNION (x', y), deleted)
else let val (y', deleted) = delete_one' y
in (UNION (x, y'), deleted)
end
end
| delete_one' (ELEM x) =
if x = w then (EMPTY, true) else (ELEM x, false)
| delete_one' x = (x, false)
val (m', _) = delete_one' m
in simplify m'
end
Haskell:
delete_one m w = do
let (m', _) = delete_one' m
simplify m'
where
delete_one' (Union x y) =
let (x', deleted) = delete_one' x
in if deleted
then (Union x' y, deleted)
else let (y', deleted) = delete_one' y
in (Union x y', deleted)
delete_one' (Elem x) =
if x == w then (Empty, True) else (Elem x, False)
delete_one' x = (x, False)
