Differences

This shows you the differences between two versions of the page.

--- codesnippets:monads [2023/06/05 01:11] – f2b216
+++ codesnippets:monads [2025/10/08 00:48] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
 ~~DISCUSSION~~
 ====== Monads ======
 ===== Example 1a =====
-  * shows how a alternative results (sum type, algebraic type, see type A, B and C in the example) can be handled and propagated in a computation by means of a function that handles such alternative results
+  * this example shows how alternative results (sum type, algebraic type, see type A, B and C in the example) can be handled and propagated in a computation by means of 'case' / 'of' constructions
-  * that function to handle such states is the function 'ifC'
+  * it works but it is quite some code
-  * examples compile warning free with GHC 9.2.7 using -Wall
+  * Code:<code Haskell>
+main :: IO ()
+main =
+    do
+        putStrLn $ show (fAListToC [(A 12), (A 7), (A 11), (A 5)] fAToB)
+        putStrLn $ show (fAListToC [(A 7), (A 13), (A 11), (A 5)] fAToB)
+        putStrLn $ show (fAListToC [(A (-1)), (A 7), (A 11), (A 5)] fAToB)
+        putStrLn $ show (fAListToC [(A 7), (A 11), (A 5), (A 13)] fAToB)
+data A a = A a | AError | ANone
+    deriving Show
+data B a = B a | BError | BNone
+    deriving Show
+data C a = C a | CError | CNone
+    deriving Show
+fAToB :: A Int -> B Int
+fAToB (A n)
+    | n <= 0 = BNone
+    | n < 13 = B (23 `div` n)
+    | otherwise = BError
+fAToB AError = BError
+fAToB ANone = BNone
+fAListToC :: [A a] -> (A a -> B a) -> C [a]
+fAListToC [] _ = C []
+fAListToC (a@(A _):lrAList) fAToB' =
+    do
+        case fAToB' a of
+            B b ->
+                let
+                    c = (fAListToC lrAList fAToB')
+                in
+                    case c of
+                        C lb -> C (b : lb)
+                        CNone -> CNone
+                        CError -> CError
+            BError -> CError
+            BNone -> CNone
+fAListToC (AError:_) _ = CError
+fAListToC (ANone:_) _ = CNone
+</code>
+  * Output:<code Haskell>
+C [1,3,2,4]
+CError
+CNone
+CError
+</code>
+===== Example 1b =====
+  * this example does not explain monads but an alternative solution where monads usually apply
+  * it shows how alternative results (sum type, algebraic type, see type A, B and C in the example) can be handled and propagated in a computation by means of a function that handles such alternative results
+  * that function handles such results by function 'ifC' and makes the job for a 'Monad' of type 'C'
+  * more detailed description of the program
+    * the function 'fAListToC' takes a list of 'A's (e.g. '[(A 12), (A 7), (A 11), (A 5)]') and transforms it to 'C' with a list of transformed data
+    * the transformation of data is according to function 'fAToB'
+    * 'fAToB' divides 23 by the number to be transformed, unless the number is 13 or greater then an error propagates ('BError'), and unless the number is 0 or smaler then no data propagates ('BNone')
+    * in 'fAListToC' 'BError' propagates to 'CError' and 'BNone' propagates to 'CNone'
+  * this example compile warning free with GHC 9.2.7 using -Wall
   * Code:<code Haskell>
@@ Line 28: / Line 94: @@
 fAToB :: A Int -> B Int
 fAToB (A n)
-    | n < 0 = BNone
+    | n <= 0 = BNone
-    | n < 13 = B (n `div` 2)
+    | n < 13 = B (23 `div` n)
     | otherwise = BError
 fAToB AError = BError
@@ Line 50: / Line 116: @@
 ifC CError _ _ bError = bError
 </code>
   * Output:<code Haskell>
-C [6,3,5,2]
+C [1,3,2,4]
 CError
 CNone
@@ Line 57: / Line 124: @@
 </code>
-===== Example 1b =====
+===== Example 1c =====
   * this example uses the instances for Functor, Applicative and Monad
@@ Line 97: / Line 164: @@
 fAToB :: A Int -> B Int
 fAToB (A n)
-    | n < 0 = BNone
+    | n <= 0 = BNone
-    | n < 13 = B (n `div` 2)
+    | n < 13 = B (23 `div` n)
     | otherwise = BError
 fAToB AError = BError
@@ Line 113: / Line 180: @@
 fAListToC (AError:_) _ = CError
 fAListToC (ANone:_) _ = CNone
+</code>
-ifC :: C a -> (a -> b) -> b -> b -> b
-ifC (C x) fThen _ _ = fThen x
-ifC CNone _ bNone _ = bNone
-ifC CError _ _ bError = bError
-</code>
   * Output:<code Haskell>
-C [6,3,5,2]
+C [1,3,2,4]
 CError
 CNone
@@ Line 242: / Line 305: @@
     Empty s       >>= _      = Empty s
     (Contains x) >>= worker = worker x
-    return                  = Contains</code>
+    return                  = Contains
+</code>
-Output:<code>
+  * Output:<code>
 Contains (Wrapper (Chopsticks {nPieces = 54, nQuality = Polished}))
 Contains (StorageBin (Chopsticks {nPieces = 34, nQuality = Polished}))
@@ Line 250: / Line 314: @@
 Empty "to short"
 Empty "to small in diameter"
-Empty "no chopsticks at packing"</code>
+Empty "no chopsticks at packing"
+</code>