# # FP101x - week 3 Defining Functions

### # Conditional Expressions

`abs :: Int -> Int`

`abs n = if n >= 0 then n else -n`

`signum :: Int -> Int`

```
signum n = if n < 0 then -1 else
if n == 0 then 0 else 1
```

### # Guarded Equations

```
abs n | n >= 0 = n
| otherwise = -n
signum n | n < 0 = -1
| n == 0 =0
| otherwise = 1
```

### # Pattern Matching

`not :: Bool -> Bool`

`not False = True`

`not True = False`

`(&&) :: Bool -> Bool -> Bool`

`True && True = True`

`True && False = False`

`False && True = False`

`False && False = False`

`True && True = True`

`_ && _ = False`

so..

`True && b = b`

`False && _ = False`

### # List Pattern

`[1,2,3,4] means 1:(2:(3:(4:[])))`

Functions on lists can be defined using

`x:xs`

patterns

```
head :: [a] -> a
head (x:_) = x
tail :: [a] -> [a]
tail (_:xs) = xs
```

`x:xs`

patterns only matches non-empty lists:

```
> head []
ERROR
```

### # Lambda Expressions

- Functions can be constructed without naming the functions by using lambda expressions
`\x -> x+x`

```
add x y = x + y
```

means

```
add = \x -> (\y -> x+y)
```

- Lambda expressions are also useful when defining functions that return functions as results

ex)

```
const :: a -> b -> a
const x _ = x
```

to lambda

```
const :: a -> ( b -> a )
const x = \_ -> x
```

### # Sections

- An operator written before its arguments by using parentheses ex)

```
> 1+ 2
3
> (+) 1 2
3
> (1+) 2
3
> (+2) 1
3
```

- Useful functions can sometimes be constructed in a simple way using sections.
- ex)
- (1+) : successor function
- (1/) : reciprocation function
- (*2) : doubling function
- (/2) : halving function