Gain insights into Haskell's functional programming by learning to write pure functions, use pattern matching, recursion, and Lists, define data types, and execute IO operations.

tarball.tar.gz

ghci

Functional programming is a problem-solving paradigm that differs drastically from the imperative programming style of languages like C++ or Java. While functional programming principles have invaded most modern programming languages to some degree, there is no language that embraces this paradigm quite as Haskell does. As a result, Haskell code can reach a level of expressiveness, safety, and elegance that is difficult to achieve in other programming languages.

This course will introduce you to the core concepts of functional programming in Haskell. You will learn how to write pure functions using techniques such as pattern matching and recursion, and how to work with Haskell's powerful List data type. You will understand the basics of Haskell's powerful type system and define your own data types. Finally, you’ll learn how to perform IO operations the Haskell way. By the end of this course, you’ll have a new paradigm to add under your belt and you can start using functional programming in your own projects.

Learn Functional Programming in Haskell

Now that we know about tuples, let's see how we can use them in functions. In principle, there are two use cases:
1. using tuples as the argument type of functions to write functions that take multiple parameters.
2. using tuples as the return type of functions to write functions that have multiple results.

# Tuples as arguments
Let's write a function which computes the perimeter of a rectangle when given its two sides `a` and `b`:


perimeter :: (Double, Double) -> Double
perimeter (a, b) = 2 * a + 2 * b

main = print (perimeter (2, 3))

In the equation of `perimeter`, we see a new kind of pattern: the tuple pattern `(a, b)`. It will match any tuple and bind its values to the pattern variables `a` and `b`. We then use these variables to compute the result. 

```
*Perimeter> perimeter (2, 3) 
10
```

We can also use literal or wildcard patterns inside tuple patterns. The function `both` checks whether both of its arguments are true:



both :: (Bool, Bool) -> Bool
both (True, True) = True
both (_, _) = False

main = do 
  print (both (True, False))
  print (both (True, True))

Formally, a tuple pattern for the tuple type `(t_1, t_2,..., t_N)` has the form 
```
(p_1, p_2, ..., p_N)
```
where `p_1` is a pattern for `t_1`, `p_2` is a pattern for `t_2` (and so on), until finally `p_N` is a pattern for `t_N`. 

The tuple pattern matches an expression `(a_1, a_2, ..., a_N)`, if `a_1` matches `p_1`, `a_2` matches `p_2`(and so on), until finally `a_N` matches `p_N`.

For example, when evaluating `perimeter (2, 3)`, the expression `(2, 3)` matches the pattern `(a, b)`, because `2` matches the pattern variable `a`, and `3` matches the pattern variable `b`.

# Patterns must be linear
There is a limitation to tuple patterns and to Haskell patterns in general: each pattern variable must only occur once in each pattern.

For example, let's continue representing rectangles as pairs of doubles. We now want to write a function which identifies whether the given rectangle is a square. It might seem natural to write it like this
```
isSquare :: (Double, Double) -> Bool
isSquare (a, a) = True -- does not compile!
isSquare (_, _) = False 
```
However, this is not allowed in Haskell, as the first equation uses the same pattern variable twice in the pattern `(a, a)`. Patterns must always be **linear** in each pattern variable.

Still, we need a way to check whether two values of a tuple are equal. We can use guarded equations to write `isSquare`:
```
isSquare :: (Double, Double) -> Bool
isSquare (a, b) | a == b    = True
                | otherwise = False
```

# Tuples as results
The simpler use case of tuples is returning multiple values from functions. Let's say we also wrote a function `area` that computes the area of rectangles
```
area :: (Double, Double) -> Double
area (a, b) = a * b
```
Let's combine our functions `area` and `perimeter` into one function that returns both:
```
areaAndPerimeter :: (Double, Double) -> (Double, Double) 
areaAndPerimeter (a, b) = (area (a, b), perimeter (a, b))
```
Here we simply use the data constructor `(,)` on the right hand side of the equation to return a tuple from the function.
```
*Perimeter> areaAndPerimeter (2, 3)
(6, 10)
```

However, our definition of `areaAndPerimeter` looks busy due to the amount of `(a, b)` tuples that we match on and pass to `area` and `perimeter` unchanged. We can write more neatly by using a pattern variable instead of the tuple pattern.

```
areaAndPerimeter :: (Double, Double) -> (Double, Double) 
areaAndPerimeter tup = (area tup, perimeter tup)
```
That is much more readable. We can also use pattern variables and wildcard patterns to match whole tuples. 

## Tuple accessors

The Haskell Prelude comes equipped with two handy accessor functions `fst` and `snd`. These work on pairs and return the first and second element, respectively.

```
*Perimeter> fst (1, 3)
1
*Perimeter> snd ("hello", False)
False
```

Using these functions, we could also write `area` or `perimeter` without pattern matching:

```
area :: (Double, Double) -> Double
area tup = fst tup * snd tup
```
However, while `fst` and `snd` do have their uses, functions with explicit pattern matching on pairs are more readable. Further, `fst` and `snd` are not defined on triples or other tuples with more elements.

# Exercise: Functions with tuples

As an exercise, write a function `ifThenElse` which takes a triple of a boolean and two ints as input. If the boolean is `True`, the function should return the first integer. If it is `False`, the function should return the second integer.

Use tuples to write functions with multiple arguments and results.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Functions with Multiple Arguments

Tuples as arguments