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

# Defining nested types

When defining custom types with `data`, we are not limited to using predefined types in the constructors. We can also nest custom types.

Let's extend our `Geometry` type (from the previous lesson) with location information. Remember, its definition was
```
data Geometry = Rectangle Double Double | Square Double | Circle Double deriving (Show)
```
The location of a shape should be the coordinates of its center point in the 2D plane. We thus identify a location by two doubles, its x and y coordinates.

```
data Coordinates = Coordinates Double Double deriving (Show)
```
Note that we are using `Coordinates` here as both the name of the type as well as the name of the only constructor. This is fine, as types and constructors have different namespaces. By convention, types with a single constructor often have the same name as the constructor.

We can now create a new type for a shape with the coordinates of its center.
```
data LocatedShape = LocatedShape Geometry Coordinates deriving (Show)
```
Located shapes can be created by nesting constructors.
```
located = LocatedShape (Square 2) (Coordinates 2 3)
```

# Functions on nested types

Given a located shape, let's write a function that takes another coordinate point and checks whether it is contained inside the shape.

```
containedIn :: Coordinates -> LocatedShape -> Bool
```

The function is used like this:
```
*Geometry> (Coordinates 5 3) `containedIn` (LocatedShape (Square 2) (Coordinates 3 3))
False
```

Here is our definition of `containedIn`.
 
```
containedIn :: Coordinates -> LocatedShape -> Bool
(Coordinates x y) `containedIn` (LocatedShape shape (Coordinates cx cy)) = 
  case shape of
    (Circle r) -> (cx - x)^2 + (cy - y)^2 <= r^2
    (Rectangle a b) -> abs (cx - x) <= a / 2 && abs (cy - y) <= b / 2
    (Square a) -> abs (cx - x) + abs (cy - y) <= a
```


At the beginning of the function equation, we are applying nested pattern matching on the located shape. 
```
(LocatedShape shape (Coordinates cx cy))
```
We already deconstructed the nested `Coordinates` value and bound the coordinates to `cx` and `cy`. On the other hand, the `shape` variable will bind to the `Geometry` value in the located shape, which we don't yet fully match. We defer matching on the shape to define the function in one equation. This makes it more readable compared to the alternative of matching everything.
```
-- full pattern matching version
containedIn :: Coordinates -> LocatedShape -> Bool
(Coordinates x y) `containedIn` (LocatedShape (Circle r) (Coordinates cx cy)) = (cx - x)^2 + (cy - y)^2 <= r^2
(Coordinates x y) `containedIn` (LocatedShape (Rectangle a b) (Coordinates cx cy)) = abs (cx - x) <= a / 2 && abs (cy - y) <= b / 2
(Coordinates x y) `containedIn` (LocatedShape (Square a) (Coordinates cx cy)) = abs (cx - x) + abs (cy - y) <= a
```
The full pattern matching version contains a lot of duplicated code because the pattern matches in the three equations, which is why the delayed matching on the shape is preferable. When complex pattern matches are involved, it is cleaner to match the types that do not have several alternative constructors (like `Coordinates` ) once in the beginning. Then, use `case` to continue matching on types that do have several alternative constructors (like `Geometry`). 

# Exercise: Pattern matching on custom types

As an exercise implement a function `move` which takes a `LocatedShape` and moves it to a new location. The direction of movement is given by a movement vector, which should be added to the coordinates of the shape.

```
data Vector = Vector Double Double
```

For example, if the shape is at `Coordinates 2 3` and the movement vector, `Vector 5 1`, is passed, the shape should move to `Coordinates 7 4`. The `Geometry` value of the shape should remain unchanged.

```
move (LocatedShape (Circle 5) (Coordinates 2 3)) (Vector 5 1) = LocatedShape (Circle 5) (Coordinates 7 4)
```


Learn to define nested Haskell data types.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Nesting Custom Types

Defining nested types