From bd16830912308e880d26ac03863e1bd192c55f53 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 9 Apr 2023 14:02:40 +0300 Subject: Update content for gemtext --- gemfeed/2010-04-09-standard-ml-and-haskell.gmi | 20 +- gemfeed/atom.xml | 320 +++++++++++++++---------- 2 files changed, 202 insertions(+), 138 deletions(-) (limited to 'gemfeed') diff --git a/gemfeed/2010-04-09-standard-ml-and-haskell.gmi b/gemfeed/2010-04-09-standard-ml-and-haskell.gmi index 0e4b3560..764e806b 100644 --- a/gemfeed/2010-04-09-standard-ml-and-haskell.gmi +++ b/gemfeed/2010-04-09-standard-ml-and-haskell.gmi @@ -12,7 +12,7 @@ Haskell is also a "pure functional" programming language, whereas SML also makes Standard ML: -``` +```sml datatype ’a multi = EMPTY | ELEM of ’a @@ -21,7 +21,7 @@ datatype ’a multi Haskell: -``` +```haskell data (Eq a) => Multi a = Empty | Elem a @@ -33,7 +33,7 @@ data (Eq a) => Multi a Standard ML: -``` +```sml 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) @@ -44,7 +44,7 @@ fun test_number w = number (UNION (EMPTY, \ Haskell: -``` +```haskell number Empty _ = 0 number (Elem x) w = if x == w then 1 else 0 test_number w = number (Union Empty \ @@ -56,7 +56,7 @@ test_number w = number (Union Empty \ Standard ML: -``` +```sml fun simplify (UNION (x,y)) = let fun is_empty (EMPTY) = true | is_empty _ = false val x’ = simplify x @@ -74,7 +74,7 @@ fun simplify (UNION (x,y)) = Haskell: -``` +```haskell simplify (Union x y) | (isEmpty x’) && (isEmpty y’) = Empty | isEmpty x’ = y’ @@ -92,7 +92,7 @@ simplify x = x Standard ML: -``` +```sml 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) @@ -103,7 +103,7 @@ fun delete_all m w = Haskell: -``` +```haskell delete_all m w = simplify (delete_all’ m) where delete_all’ (Elem x) = if x == w then Empty else Elem x @@ -115,7 +115,7 @@ delete_all m w = simplify (delete_all’ m) Standard ML: -``` +```sml fun delete_one m w = let fun delete_one’ (UNION (x,y)) = let val (x’, deleted) = delete_one’ x @@ -135,7 +135,7 @@ fun delete_one m w = Haskell: -``` +```haskell delete_one m w = do let (m’, _) = delete_one’ m simplify m’ diff --git a/gemfeed/atom.xml b/gemfeed/atom.xml index 1a87ed65..f434f1ef 100644 --- a/gemfeed/atom.xml +++ b/gemfeed/atom.xml @@ -1,6 +1,6 @@ - 2023-04-09T13:51:48+03:00 + 2023-04-09T14:02:25+03:00 foo.zone feed To be in the .zone! @@ -7538,131 +7538,193 @@ first 10 nat_pairs_not_null I am currently looking into the functional programming language Standard ML (aka SML). The purpose is to refresh my functional programming skills and to learn something new too. Since I already knew a little Haskell, I could not help myself, and I also implemented the same exercises in Haskell.
-

Standard ML and Haskell

-

Published at 2010-04-09T22:57:36+01:00

-

I am currently looking into the functional programming language Standard ML (aka SML). The purpose is to refresh my functional programming skills and to learn something new too. Since I already knew a little Haskell, I could not help myself, and I also implemented the same exercises in Haskell.

-

As you will see, SML and Haskell are very similar (at least when it comes to the basics). However, the syntax of Haskell is a bit more "advanced". Haskell utilizes fewer keywords (e.g. no val, end, fun, fn ...). Haskell also allows to write down the function types explicitly. What I have been missing in SML so far is the so-called pattern guards. Although this is a very superficial comparison for now, so far, I like Haskell more than SML. Nevertheless, I thought it would be fun to demonstrate a few simple functions of both languages to show off the similarities.

-

Haskell is also a "pure functional" programming language, whereas SML also makes explicit use of imperative concepts. I am by far not a specialist in either of these languages, but here are a few functions implemented in both SML and Haskell:

-

Defining a multi-data type

-

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
-

-

Processing a multi

-

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
-

-

Simplify function

-

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
-

-

Delete all

-

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
-

-

Delete one

-

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
+                
Standard ML and Haskell


+

+Published at 2010-04-09T22:57:36+01:00

+

+I am currently looking into the functional programming language Standard ML (aka SML). The purpose is to refresh my functional programming skills and to learn something new too. Since I already knew a little Haskell, I could not help myself, and I also implemented the same exercises in Haskell.

+

+As you will see, SML and Haskell are very similar (at least when it comes to the basics). However, the syntax of Haskell is a bit more "advanced". Haskell utilizes fewer keywords (e.g. no val, end, fun, fn ...). Haskell also allows to write down the function types explicitly. What I have been missing in SML so far is the so-called pattern guards. Although this is a very superficial comparison for now, so far, I like Haskell more than SML. Nevertheless, I thought it would be fun to demonstrate a few simple functions of both languages to show off the similarities. 

+

+Haskell is also a "pure functional" programming language, whereas SML also makes explicit use of imperative concepts. I am by far not a specialist in either of these languages, but here are a few functions implemented in both SML and Haskell:

+

+
Defining a multi-data type


+

+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
+

+

+
Processing a multi


+

+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
+

+

+
Simplify function


+

+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
+

+

+
Delete all


+

+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
+

+

+
Delete one


+

+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)
-


-
Higher-order functions

-
The first line is always the SML code, the second line the Haskell variant:

+    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)
+
+
+

Higher-order functions


+
+The first line is always the SML code, the second line the Haskell variant:
+
 fun make_map_fn f1 = fn (x,y) => f1 x :: y
 make_map_fn f1 = \x y -> f1 x : y
@@ -7675,9 +7737,11 @@ my_map f l = foldr (make_map_fn f) [] l
 
 fun my_filter f l = foldr (make_filter_fn f) [] l
 my_filter f l = foldr (make_filter_fn f) [] l
-

-

E-Mail your comments to hi@paul.cyou :-)

-Back to the main site
+ +
+E-Mail your comments to hi@paul.cyou :-)
+
+Back to the main site
 -- cgit v1.2.3