This is an old revision of the document!

Binding

A binding binds a name or even several names with a function definition.

In Haskell, a binding is defined by symbol “=” whereas

on the left hand side
1. the function name and its parameters
2. or a pattern is given,
and on the right had side the definition of the function.

examples
- compile, error and warning free, with compiler: GHC 8.10.4, using compiler option -Wall

Binding with a) function name and parameter

function name an parameter (half x), on the left hand side of the equal sign (=)
- half is the function that can take parameter x
- half can be evaluated by name with a parameter just right behind the function name (e.g. half 5)
function definition (x / 2), on the right hand side
- if half is demanded to be evaluated then the result is delegated to function (/) with parameter x and 2
example
- code line:
```
half x = x / 2
```
- works in:
```
main :: IO ()
main = 
    do
            print (half 5)
 
half x = x / 2
```
- with compiler warning, which we ignore for pedagogical reasons
- executes, with output:
```
2.5
```
- 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.

Binding with b) pattern matching

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

Lists

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:
```
[first, b, zet] = [13, 17, 19]
```

works in:

main :: IO ()
main = 
    do
        print first
        print b
        print zet
 
[first, b, zet] = [13, 17, 19]

with compiler warning, which we ignore for pedagogical reasons
executes, with output:
```
13
17
19
```

Tuples

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
  - cannot be empty
  - cannot have a single element only
- the type of the tuple is the tuple with the order of types
- 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:
```
[first, b, zet] = [13, 17, 19]
```

works in:

main :: IO ()
main = 
    do
        print first
        print b
        print zet
 
(first, b, zet) = ('a',12,23.4)

with compiler warning, which we ignore for pedagogical reasons
executes, with output:
```
'a'
12  
23.4
```

Example 2

Person name number = Person "Lutz" 1243

…works in…

module Main where
 
main :: IO ()
main = 
        do
                print name
                print number
 
data Person = Person { sName :: String, iNumber :: Integer }
 
Person name number = Person "Lutz" 1243

You could leave a comment if you were logged in.

HaskSheet

Table of Contents