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

# Evaluation order and termination
Previously, we saw that the order of evaluation does not influence the result of expressions. This changes, however, when non-termination comes into play.

As an example, let's revisit once more our function `both`, the reimplementation of the conjunctive boolean `&&` operator:

both :: Bool -> Bool -> Bool
both False _ = False
both True b  = b

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

The function `both` is implemented by pattern matching on the first argument. If the first argument is already `False`, we know that the result is `False` and do not need to check the second argument. If the first argument is `True`, we do need to check the second argument, and its truth value will be the result.

Now, let's again use our looping function,
```
loop :: Bool -> Bool
loop x = loop x
``` 
and evaluate the expression `both False (loop True)`. A first approach could be to start with evaluating the subexpression `loop True`:
```
both False (loop True)
 = both False (loop True)
 = both False (loop True)
 = ...
```
This makes no progress and leads to a nonterminating computation. So, let's try another idea: start by checking the equations for `both` to look for matching patterns. The first equation will match. The first argument is `False`, and for the second argument we have a wildcard pattern that matches anything. We can apply the first equation and obtain:
```
both False (loop True) = False
```
The first evaluation strategy, where we started by evaluating the function argument `loop (True)` to our `both` function, leads to a nonterminating computation. On the contrary, the second evaluation strategy, where we kept the function argument as it is and instead tried to progress by applying function equations, leads to a result.

## Strict vs. lazy

The first strategy is called **strict evaluation**. It evaluates all function arguments fully before applying the function itself. This evaluation strategy is used in imperative programming languages such as **C++** or **Java**.

The second strategy is called **lazy evaluation**. It evaluates arguments to functions only when they are needed to compute the results. In Haskell, this means that function arguments are only evaluated if this is necessary to determine whether the pattern of an equation matches. 

The following results hold for strict and lazy evaluation in Haskell:

1. If both the strict and lazy evaluation terminate, they have the same result.
2. If the strict evaluation terminates, then the lazy evaluation terminates.
3. There are expressions where lazy evaluations terminate and strict evaluations do not terminate.

Thus, in terms of termination behavior, lazy evaluation can evaluate more expressions than strict evaluation. That is why Haskell is using lazy evaluation as its evaluation strategy. 




Let's discuss the evaluation strategy of Haskell, called lazy evaluation.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Lazy Evaluation

Evaluation order and termination