codesnippets:bindingandpatternmatching
Differences
This shows you the differences between two versions of the page.
| Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
| codesnippets:bindingandpatternmatching [2021/04/14 05:22] – [Lists] f2b216 | codesnippets:bindingandpatternmatching [2025/10/08 00:48] (current) – external edit 127.0.0.1 | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Binding ====== | + | ====== Binding |
| - | ~~DISCUSSION~~ | + | |
| A binding binds a name or even several names with a function definition. | A binding binds a name or even several names with a function definition. | ||
| Line 46: | Line 45: | ||
| ==== Lists ==== | ==== Lists ==== | ||
| - | * lists can be written in the form '' | + | |
| - | * whereas '' | + | |
| - | * the elements between brackets are comma seperated | + | * whereas '' |
| - | * all elements of a lists have the same type | + | * the elements between brackets are comma seperated |
| - | * an empty list is of type '' | + | * all elements of a lists have to have the same type |
| - | * lists can also be written in the form <elem 1> : <elem 2> : ... <elem n> : '' | + | * list can be defined infinite |
| - | * '':'' | + | |
| - | * '':'' | + | * lists can also be written in the form <elem 1> : <elem 2> : ... <elem n> : '' |
| - | * e.g. '' | + | * '':'' |
| - | * lists can be written in a mixed form <elem 1> : <elem 2> : ... <elem n> : '' | + | * '':'' |
| - | * e.g. '' | + | * e.g. '' |
| + | * lists can be written in a mixed form <elem 1> : <elem 2> : ... <elem n> : '' | ||
| + | * e.g. '' | ||
| + | * pattern maching with lists | ||
| + | * in the same form as thay are constructed above | ||
| + | * but with binding names | ||
| * example | * example | ||
| * code line:< | * code line:< | ||
| - | half x = x / 2 | + | [first, b, zet] = [13, 17, 19] |
| </ | </ | ||
| * works in:<code Haskell> | * works in:<code Haskell> | ||
| Line 66: | Line 69: | ||
| main = | main = | ||
| do | do | ||
| - | | + | |
| + | print b | ||
| + | print zet | ||
| - | half x = x / 2 | + | [first, b, zet] = [13, 17, 19] |
| </ | </ | ||
| * with compiler warning, which we ignore for pedagogical reasons | * with compiler warning, which we ignore for pedagogical reasons | ||
| * executes, with output:< | * executes, with output:< | ||
| - | 2.5 | + | 13 |
| + | 17 | ||
| + | 19 | ||
| </ | </ | ||
| - | * NOTE: The term '' | ||
| - | ==== Example 2 ==== | + | ==== Tuples |
| - | <code Haskell> | + | * tuple construction |
| - | Person name number | + | * tuples are written in the form '' |
| + | * 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] | ||
| </ | </ | ||
| - | + | * works in:<code Haskell> | |
| - | ...works in... | + | |
| - | + | ||
| - | <code Haskell> | + | |
| - | module Main where | + | |
| main :: IO () | main :: IO () | ||
| main = | main = | ||
| - | | + | |
| - | print name | + | print first |
| - | print number | + | print b |
| + | print zet | ||
| - | data Person = Person { sName :: String, iNumber :: Integer } | + | (first, b, zet) = (' |
| - | + | ||
| - | Person name number | + | |
| </ | </ | ||
| - | + | * with compiler warning, which we ignore for pedagogical reasons | |
| - | ==== Example 3 ==== | + | * executes, with output:< |
| - | + | 'a' | |
| - | < | + | 12 |
| - | (x1, Person x2 x3, x4) = (" | + | 23.4 |
| </ | </ | ||
| - | ...works in... | + | ==== Algebraic data types ==== |
| - | + | ||
| - | <code Haskell> | + | |
| - | module Main where | + | |
| + | * type definitions | ||
| + | * algebraic data types can be defined in the form '' | ||
| + | * whereas '' | ||
| + | * 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 < | ||
| + | * 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:< | ||
| + | data MyData = MyVariantA Integer Char Double | MyVariantB Int | MyVariantC | ||
| + | MyVariantA first b zet = MyVariantA 12 ' | ||
| + | </ | ||
| + | * work in:<code Haskell> | ||
| main :: IO () | main :: IO () | ||
| main = | main = | ||
| - | | + | |
| - | print x1 | + | print first |
| - | print x2 | + | print b |
| - | print x3 | + | print zet |
| - | print x4 | + | |
| - | data Person | + | data MyData |
| - | (x1, Person x2 x3, x4) = (" | + | MyVariantA first b zet = MyVariantA 12 'a' |
| - | </ | + | |
| + | MyVariantB n = MyVariantB 123 | ||
| + | MyVariantC = MyVariantC -- is not binding anything, but compiles consistently | ||
| + | </ | ||
| + | * with compiler warning, which we ignore for pedagogical reasons | ||
| + | * executes, with output:< | ||
| + | 12 | ||
| + | ' | ||
| + | 23.4 | ||
| + | 123 | ||
| + | </ | ||
| + | * NOTE: I may look like: It does' | ||
| + | |||
| + | ===== ✎ ===== | ||
| + | ~~DISCUSSION~~ | ||
codesnippets/bindingandpatternmatching.1618370572.txt.gz · Last modified: (external edit)