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:
fun v_v_mult [] _ = 0
| v_v_mult _ [] = 0
| v_v_mult vs ws =
let val prods = map (fn (v, w) => v * w) (zip vs ws)
in foldr op+ 0 prods
end
Haskell:
v_v_mult :: (Num a) => [a] -> [a] -> a
v_v_mult [] _ = 0
v_v_mult _ [] = 0
v_v_mult vs ws =
let prods = map (\(v, w) -> v * w) (zip vs ws)
in foldr (+) 0 prods
Standard ML:
fun m_v_mult [] _ = []
| m_v_mult (vs::vss) ws =
let val sum = v_v_mult vs ws
in sum :: m_v_mult vss ws
end
Haskell:
m_v_mult :: (Num a) => [[a]] -> [a] -> [a]
m_v_mult [] _ = []
m_v_mult (vs:vss) ws =
let sum = v_v_mult vs ws
in sum : m_v_mult vss ws
Standard ML:
fun m_m_mult _ [] = []
| m_m_mult vss (ws::wss) =
let val sums = m_v_mult vss ws
in sums :: m_m_mult vss wss
end
Haskell:
m_m_mult :: (Num a) => [[a]] -> [[a]] -> [[a]]
m_m_mult _ [] = []
m_m_mult vss (ws:wss) =
let sums = m_v_mult vss ws
in sums : m_m_mult vss wss
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)
