Lab 4: Comprehending Lists
You may work singly or in pairs on this lab: If you work with a partner,
turn in a single solution with both names on it.
1 Lists
In Haskell, a list is a sequence of values, all having the same type. For example,
[1,3,5,6] is a 4-element list of Ints, whereas [True,False,False,True,False]
is a 5-element list of Bools.
Generally speaking, the lists that we’ll be using will be finite (in particular, all of
the lists we use in this lab will be finite, with one exception). However, Haskell
does allow us to define and use infinite lists; we’ll talk about the use of infinite
lists later this semester.
In Haskell, strings are lists of characters, just as strings in C are just arrays of
characters. If you evaluate the expression [’a’, ’b’, ’c’] in the Hugs inter-
preter, you’ll get the following response: "abc".
Haskell provides mechanisms for the easy definition of certain lists. Evaluate each
of the following at the Hugs prompt:
[1 .. 10]
[15 .. 20]
[15 .. (20-5)]
[’q’ .. ’z’]
[14 .. 2]
You no doubt noticed the pattern here: for numbers, characters and other enu-
merated types (something else we haven’t talked about yet!), the expression
[m.. n]yields the list [m,m+ 1,m+ 2, ..., n]. In the cases where n
is less than m(such as the last example above), the empty list [] is returned.
More generally, the expression [m,p.. n]yields the list
[m,m+ (p−m),m+ 2(p−m),m+ 3(p−m), ..., n0]
where n0is as close as possible to nwithout exceeding it. The book explains this
notation a bit more precisely, but you should have the basic idea. Evaluate each
of the following, to make sure you understand this notation:
[1,3 .. 10]
[15,15.5 .. 20]
[1.0, 1.2 .. 2.0]
[’a’,’d’ .. ’z’]
[10,8 .. -3]
[1,2 .. 0]
What do you think would happen if you evaluated the following expression? (You
can try it out to check your answer if you want, but be prepared to type C-c C-c
to stop the Hugs evaluation; you may also need to delete the Hugs buffer (C-x k).)
[9,9 .. 10]
2 List Comprehensions
Haskell also provides a powerful mechanism known as list comprehension, which
provides a convenient way for defining lists from previous lists.
A list comprehension typically comprises three parts: (1) a generator, (2) some
number (sometimes zero) of tests, and (3) a transformation. The generator ex-
tracts elements from an existing list, the tests work as filters to select some of
those extracted elements, and the transformation uses those selected elements to
create the resulting list.
For example, consider the following expression:
[ (x,True) | x <- [1 .. 20], even x, x < 15 ]
Here, x <- [1 .. 20] is the generator, the tests are even x and x < 15,
and (x,True) is the transformation. This expression creates a list of all pairs
(x,True), where xis between 1and 20, even, and less than 15. (Recall that
even is defined in Haskell’s standard Prelude.)
Evaluate this expression, and notice that the elements appear in the order that
they were generated. Compare that result to the evaluation of the following:
[ (x,True) | x <- [20, 19 .. 1], even x, x < 15 ]
Once again, the elements appear in the order that they were generated.
As another example, consider the following:
[ [m+n] | (m,n) <- [(3,6), (7,3), (8,4), (1,3), (4,8)], n == 2*m]
CIS 252 (Spring 2009) — Introduction to Computer Science Page 1
