Question

I have always been challenged by the way lists work and am confused about the whole (x:xs) concept. I just don’t seem to be getting my head around it.

Example

select :: Ord a => a -> [a] -> [a]
select y [] = []
select y (x:xs)
    | x < y     = x : select y xs
    | otherwise = select y xs

P.S. I know exactly what the function does, but would anyone be able to explain the process (including especially the weird Ord a and => signs)?

Any effective strategies would be much appreciated.

Thanks in advance. Ian.

Answer 1

Ok. Let’s walk through the different syntactic elements here.

Line 1

select :: Ord a => a -> [a] -> [a]

This is a type declaration. It is the declaration of a function (since it has -> types).

The function has two arguments.

• The first is a single value of any type, signified by a (lower case means it is a polymorphic type).
• The second argument is a list of any type that is the same as the first argument.

The return value is a list of any type, the same as the argument types.

The Ord a component is a typeclass constraint, that says that any type this function is given must also be an instance of the Ord class. This is a class of types that can be compared.

Line 2

Now we look at line 2:

select y [] = []

This is one definition of the select function itself. It is very simple, containing patterns for the two arguments, and a specification of the result. It reads:

if the first argument is any value (which we will name y), and the second argument is the empty list (denoted by the [] pattern), then select evaluates to the empty list.

Line 3

Line 3 contains the other case for lists:

select y (x:xs)

Again, this is part of the definition of the select function, for the case when the second argument is not an empty list. If it is not an empty list, then it is a list with a head, x, and a tail xs. The “cons” constructor, (:) combines a list head and tail. It is also how we pattern match on a list, to extract the head and tail.

By pattern matching on the head and tail of the list, with (x:xs), we bind a new variable, x, to the value of the head of the list, and xs to value of the tail of the list.

Lines 4 and 5

The last two lines are additional guards that test and branch based on additional checks, should the second argument be a non-empty list:

| x < y     = x : select y xs
| otherwise = select y xs

The first guard fires when x is less than the first argument, y. If so, we return a new list with x at the head, and select applied again to the tail.

If that is not the case, then we drop x from the list, and return only what happens when tail is called recursively.

---

For more information on how Haskell works, I recommend introductory texts such as:

• Learn You a Haskell for Great Good.
• Programming in Haskell.
• The Craft of Functional Programming.

it will be worth your time.