2019-09-12 22:51

Page 1

Lists and recursion

(Pattern matching, recursion, testing list functions)

Page 2

List Syntax

[5,6,3] == 5 : 6 : 3 : [] == 5 : ( 6 : (3 : []))

```
[]
```
is often called nil
```
(:)
```
is often called cons
- These names first appeared in Lisp 61 years ago.
- Because of Lisp, lists still have a central place in functional programming languages.

Page 3

List constructors

Under the hood, all lists are build with two constructors:
- The empty list
  - [] :: [a]
- Adding one more element to the front of a list
  - (:) :: a -> [a] -> [a]
It's like the list type is a data type with two constructors!

Page 4

The List type, defined

If the list type was defined in a data type definition, it would look like this:

data [a] = [] | a : [a]    deriving (Eq,Ord)

Page 5

The List type, defined

If the list type was defined in a data type definition, it would look like this:
- ```
data [a] = [] | a : [a]
```
If we write it with normal names for the type and constructors:
- ```
data List a = Nil | Cons a (List a)
```
Similar to what we have seen before, but:
- Data types can have type parameters!
- Data types can be recursive!
- We will return to recursive data types in a later lecture.

Page 6

Live Demo

QuickCheck examples with list functions and preconditions:
- Source code: Lists1.hs (continued from last time)
List comprehensions, more list functions:
- Source code: Lists2.hs

Page 7

A pitfall which QuickCheck in GHCi

prop_reverse xs = reverse (reverse xs) == xs

nonprop_reverse xs = reverse xs == xs

quickCheck prop_reverse +++ OK, passed 100 tests. quickCheck nonprop_reverse +++ OK, passed 100 tests.
Not good! Checking the types

prop_reverse    :: Eq a => [a] -> Bool
nonprop_reverse :: Eq a => [a] -> Bool

QuickCheck doesn't work on polymorphic types, somehow a more specific type got selected.

Page 8

Extended defaulting in GHCi

GHCi tries to be helpful by choosing a specific type instead of complaining about unresolved overloading.

This means that

quickCheck nonprop_reverse

will test

```
nonprop_reverse :: [()] -> Bool
```

GHCi picks the unit type
```
()
```
, a type containing only one value
```
()
```
.
- ```
data () = ()
```
But when all elements in the list are the same, it doesn't matter in which order we put them!
The test is OK if we only care about the length of the lists, but otherwise we have a problem.

Page 9

Avoiding the pitfall which QuickCheck in GHCi

Testing polymorphic functions without falling into the pitfall

In the source code
- Add type signatures to your properties to get control over which types are used in testing.
Or, in GHCi
- Restrict the types used in defaulting to the standard ones in Haskell:
- default (Integer,Double)

Page 10

Summary

We have seen

QuickCheck examples with list functions and preconditions
- Make sure sensible types are used when testing
Various uses of list comprehensions
More recursive list functions
Inefficient and efficient variants of
```
reverse
```
- Measuring computation time in GHCi by using :set +s