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

Let's focus some more on Haskell's basic data types. After all, just using arithmetic operations does not allow us to write interesting functions.

In this lesson, we will be using `ghci` again, which you can run from the following terminal window:

# The `Bool` type
`Bool` is the data type of truth values, named in honor of the famous logician **George Boole**. It contains exactly two distinct values: `True` and `False`.

Booleans can be negated with `not` or combined with the binary operators `&&` (conjunction) and `||` (disjunction).

```
Prelude> not True
False
Prelude> True || False
True
Prelude> True && False
False
```

Booleans also appear as the result of comparison operators. The operator `==` checks two values for equality. It can only be used on values of the same type, anything else is a type error.

```
Prelude> 5 == 5
True
Prelude> True == False
False
```
The operator for inequality is `/=` in Haskell. This is different from most other programming languages, which use `!=`. 

Additionally, there are comparison operators `<`, `<=`, `>` and `>=` that can be used on numbers. Their results are also `Bool` values.
```
Prelude> 5 < 7
True
Prelude> 9 >= 11.5
False
Prelude> -3 <= -3
True
```
## Showing types

Let's use booleans to illustrate a handy feature of `ghci`. Since the compiler infers the type of each expression, `ghci` can also print them for you. Simply prefix an expression with `:t`. 

```
Prelude> :t True
True :: Bool
Prelude> :t not
not :: Bool -> Bool
```
It even works for functions. You might wonder why we did not introduce it while looking at numeric types. Numeric types are, in fact, more complicated than we have considered so far.
```
Prelude> :t 5
5 :: Num p => p
```
The inferred type of `5` is neither `Int` nor `Double`, as we might have expected. Instead `Num p => p` is a constraint on the type of `5` (meaning, `5` has the type `p`, and `p` is some numeric type). So, by only seeing `5`, we cannot decide whether it should be used as an integer or a floating point number. We should not settle for a concrete type yet. After all, `5` could be used in both contexts:
```
Prelude> div 5 2
2
Prelude> 5 / 2
2.5
```
`div 5 2` should be type `Int` then, right?
```
Prelude> :t div 5 2
div 5 2 :: Integral a => a
```
Wrong. There are several integer types! So all we can say about `div 5 2` is that it has some integral type `a`, as expressed by `Integral a => a`. 


We won't go into the detailed meaning of type constraints or the numeric type hierarchy yet. At this moment, it is enough to understand that `Num p => p` means "some numeric type" or `Integral a => a` means "some integer type". We will obtain a better understanding of such constraints in a later lesson on **type classes**.

An introduction to the Boolean data type and some of its predefined functions.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Booleans