Differences

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

--- codesnippets:bindingandpatternmatching [2021/04/13 21:40] – [a) with function name and parameter] f2b216
+++ codesnippets:bindingandpatternmatching [2025/10/08 00:48] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
-====== Binding ======
+====== Binding and pattern matching ======
-~~DISCUSSION~~
 A binding binds a name or even several names with a function definition.
@@ Line 13: / Line 12: @@
     * compile, error and warning free, with compiler: GHC 8.10.4, using compiler option -Wall
-===== a) with function name and parameter =====
+===== Binding with a) function name and parameter =====
   * function name an parameter (''half x''), on the left hand side of the equal sign (''='')
@@ Line 27: / Line 26: @@
 main :: IO ()
 main =
-        do
+    do
-                print $ half 5
+            print (half 5)
-default (Double)
 half x = x / 2
@@ Line 38: / Line 35: @@
 .5
 </code>
+    * NOTE: The term ''half 5'' is in round brackets, which means ''half 5'' has to be evaluated and its result is the first parameter of print. The expression ''print half 5'' would lead to a compiler error, beause this would be interpreted as print has two parameters.
-===== 2) with pattern matching =====
+===== Binding with b) pattern matching =====
-==== Example 1 ====
+  * pattern matching needs the knowledge of tuples, arrays, and algebraic data types
+  * unfortunately tuples, arrays, and algebraic data types can only be fully understood with pattern matching
+  * this is attempt to explain both at the same time, while keeping the **__focus on bindings__**
-<code Haskell>
+==== Lists ====
-(x1, x2, x3) = (42, "Hello", "World")
-</code>
-...works in...
-<code Haskell>
-module Main where
+  * list construction
+    * lists can be written in the form ''['' <elem 1>, <elem 2>, ... <elem n>'']''
+      * whereas ''[]'' is an empty list
+      * the elements between brackets are comma seperated
+    * all elements of a lists have to have the same type
+    * list can be defined infinite
+    * an empty list is of type ''[a]'', whereas ''a'' is a type parameter
+    * lists can also be written in the form  <elem 1> : <elem 2> : ... <elem n> : ''['' '']''
+      * '':'' is an operator that appends an element on the left hand side to a list on the right hand side
+      * '':'' is associated to the right
+      * e.g. ''3 : 2 : []'' equals ''(3 : (2 : []))''
+    * lists can be written in a mixed form  <elem 1> : <elem 2> : ... <elem n> : ''['' <elem n+1>, <elem n+2>, ... <elem m>'']''
+      * e.g. ''(3 : (2 : []))'' equals ''3 : [2]'' equals ''[3, 2]''
+  * pattern maching with lists
+    * in the same form as thay are constructed above
+    * but with binding names
+  * example
+    * code line:<code Haskell>
+[first, b, zet] = [13, 17, 19]
+</code>
+    * works in:<code Haskell>
 main :: IO ()
 main =
-        do
+    do
-                print x1
+        print first
-                print x2
+        print b
-                print x3
+        print zet
-(x1, x2, x3) = (42, "Hello", "World")
+[first, b, zet] = [13, 17, 19]
 </code>
+    * with compiler warning, which we ignore for pedagogical reasons
-==== Example 2 ====
+    * executes, with output:<code>
-<code Haskell>
-Person name number = Person "Lutz" 1243
 </code>
-...works in...
+==== Tuples ====
-<code Haskell>
-module Main where
+  * tuple construction
+    * tuples are written in the form ''('' <elem 1>, <elem 2>, ... <elem n>'')''
+      * elements between brackets are comma seperated
+    * elements of a tuple can have different types
+    * tuples can contain two or more elements
+      * cannot be empty
+      * cannot have a single element only
+    * the type of the tuple is the tuple with the order of types e.g. (Char, Int, Double)
+    * elements of tuples are finite
+  * pattern maching with tuples
+    * in the same form as thay are constructed above
+    * but with binding names
+  * example
+  *
+    * code line:<code Haskell>
+[first, b, zet] = [13, 17, 19]
+</code>
+    * works in:<code Haskell>
 main :: IO ()
 main =
-        do
+    do
-                print name
+        print first
-                print number
+        print b
+        print zet
-data Person = Person { sName :: String, iNumber :: Integer }
+(first, b, zet) = ('a',12,23.4)
-Person name number = Person "Lutz" 1243
 </code>
+    * with compiler warning, which we ignore for pedagogical reasons
-==== Example 3 ====
+    * executes, with output:<code>
+'a'
-<code Haskell>
-(x1, Person x2 x3, x4) = ("...", Person "Lutz" 1243, '#')
+.4
 </code>
-...works in...
+==== Algebraic data types ====
-<code Haskell>
-module Main where
+  * type definitions
+    * algebraic data types can be defined in the form ''data'' <TypeName> ''='' <DataConstructorA> <DataTypeA1> <DataTypeA2> ... <DataTypeAN> ''|'' <DataConstructorB> <DataTypeB1> <DataTypeB2> ... <DataTypeBM> ''|'' <DataConstructorO> ...
+    * whereas ''|'' devides variants simmilar to variants in unions in programming the language C and C++
+    * each variant has to have a constructor
+    * each constructor can contain zero, one or more data types
+  * construction of data of algebraic data types
+    * constructed in the form <DataConstructor> <Value1> <Value2> ... <ValueN>
+    * whereas the values have to conform with the data type declaration
+  * pattern maching with tuples
+    * in the same form as thay are constructed above
+    * but with binding names
+  * example
+    * code lines:<code Haskell>
+data MyData = MyVariantA Integer Char Double | MyVariantB Int | MyVariantC
+MyVariantA first b zet = MyVariantA 12 'a' 23.4
+</code>
+    * work in:<code Haskell>
 main :: IO ()
 main =
-        do
+    do
-                print x1
+        print first
-                print x2
+        print b
-                print x3
+        print zet
-                print x4
-data Person = Person { sName :: String, iNumber :: Integer }
+data MyData = MyVariantA Integer Char Double | MyVariantB Int | MyVariantC
-(x1, Person x2 x3, x4) = ("...", Person "Lutz" 1243, '#')
+MyVariantA first b zet = MyVariantA 12 'a' 23.4
-</code>
+MyVariantB n = MyVariantB 123
+MyVariantC = MyVariantC -- is not binding anything, but compiles consistently
+</code>
+    * with compiler warning, which we ignore for pedagogical reasons
+    * executes, with output:<code>
+'a'
+.4
+</code>
+  * NOTE: I may look like: It does'nt make sense to have a constructor no elements. However, ''MyVariantC'' is already a value in itself, and can be used to differentiate between the variants.
+===== ✎ =====
+~~DISCUSSION~~