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

Before we dive deeper into writing functions on lists, let's look at some of the most important predefined functions operating on lists. Here is a terminal running `ghci`, in which you can experiment with the various functions:



# Checking length

The `length` function returns the number of elements in a list of any type.
```
Prelude> length [2, 4, 4, 1]
4
Prelude> length []
0
```

# Checking list membership

The `elem` function checks whether a value is contained in a list at least once, and returns a boolean answer. It works on all lists whose element types can be compared with `==`. 
```
Prelude> elem 1 [9, 2, 1]
True
Prelude> elem 4 [9, 2, 1]
False
Prelude> 2 `elem` [9, 2, 1] -- use as operator
True
```

# Appending lists

The `++` operator can be used to concatenate two lists together. The lists must be of the same type.
```
Prelude> [1, 6, 3] ++ [-4, 5, 6]
[1, 6, 3, -4, 5, 6]
```
We already know `++` as the string concatenation operator, and they are actually the same function. This is because the `String` type in Haskell is an alias for `[Char]`. A string is simply a list of characters, and `"hi"` is syntactic sugar for `'h' : 'i' : []`.

If we have a nested list of lists, we can chain them together to one list using the `concat` function.
```
Prelude> concat [[5, 2], [3, 7], [8, 4, 2]]
[5, 2, 3, 7, 8, 4, 2]
```

# Accessing elements

The `!!` operator can be used to access elements in a list by their index. The first element has index `0`.
```
Prelude> [1.0, 2.5, 3.7] !! 0
1.0
Prelude> [1.0, 2.5, 3.7] !! 2
3.7
```
The functions `head` and `last` can be used to access the first and last elements of a list respectively.
```
Prelude> head [1.0, 2.5, 3.7]
1.0
Prelude> last [1.0, 2.5, 3.7]
3.7
```
The `!!` operator is **unsafe**, it can throw a runtime error if the given index is out of bounds. Also, `head` and `last` can throw errors when called on the empty list. This is why these functions should only be used when we can be sure that our lists are long enough (for example, when working on predefined constant lists). If we need to handle lists of unknown length, the better alternative is pattern matching.

# Accessing sublists

We can use `take n` to obtain a prefix of a list containing the first `n` elements.
```
Prelude> take 2 [1, 1, 6, -2]
[1, 1]
```
If the list is shorter than the integer argument to `take`, the whole list is returned. 

Similarly, `drop n` returns the list with the first `n` elements removed.
```
Prelude> drop 2 [1, 1, 6, -2]
[6, -2]
```
If the list has fewer elements than are dropped, the empty list is returned. For any integer `n` and any list `xs`, it holds that `take n xs ++ drop n xs` equals `xs`.

The deconstruction counterpart to `head` is `tail`. It returns the sublist containing all but the first element. Similarly, `init` is the counterpart to `last` and returns the sublist of all but the last element.
```
Prelude> tail [1, 2, 3]
[2, 3]
Prelude> init [1, 2, 3]
[1, 2]
```
Every nonempty list `xs` can be written as `head xs : tail xs`. Like `head` and `last`, `init` and `tail` are also unsafe, as they fail on empty lists.

# Combining lists

The `zip` function can be used to combine two lists (like a zip fastener), producing a list of pairs.
```
Prelude> zip [1, 2, 3] ['a', 'b', 'c']
[(1, 'a'), (2, 'b'), (3, 'c')]
```
If one of the zipped lists is longer than the other, the extra elements of the longer list are ignored.
```
Prelude> zip [1, 2, 3] ['a', 'b']
[(1, 'a'), (2, 'b')]
```

Learn about the most important utility functions on lists.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Common Functions on Lists

Checking length

Checking list membership

Appending lists