Question

I am new to Haskell and am trying to learn the basics. I am having a hard time understanding how to manipulate the contents of a list.

Assume I have the following list and I would like to create a function to subtract 1 from every element in the list, where I can simply pass x to the function, how would this be done?

Prelude>let x = 1:2:3:4:5:[]

Something like:

Prelude>subtractOne(x)

Answer 1

(You can write 1:2:3:4:5:[] more simply as [1,2,3,4,5] or even [1..5].)

Comprehensions

You’d like to use list comprehensions, so here it is:

subtractOne xs = [ x-1 | x <- xs ]

Here I’m using xs to stand for the list I’m subtracting one from.

The first thing to notice is x <- xs which you can read as “x is taken from xs“. This means we’re going to take each of the numbers in xs in turn, and each time we’ll call the number x.

x-1 is the value we’re calculating and returning for each x.

For more examples, here’s one that adds one to each element [x+1|x<-xs] or squares each element [x*x|x<-xs].

More than one list

Let’s take list comprehension a little further, to write a function that finds the squares then the cubes of the numbers we give it, so

> squaresAndCubes [1..5]
[1,4,9,16,25,1,8,27,64,125]

We need

squaresAndCubes xs = [x^p | p <- [2,3], x <- xs]

This means we take the powers p to be 2 then 3, and for each power we take all the xs from xs, and calculate x to the power p (x^p).

What happens if we do that the other way around?

squaresAndCubesTogether xs = = [x^p | x <- xs, p <- [2,3]]

We get

> squaresAndCubesTogether [1..5]
[1,1,4,8,9,27,16,64,25,125]

Which takes each x and then gives you the two powers of it straight after each other.

Conclusion – the order of the <- bits tells you the order of the output.

Filtering

What if we wanted to only allow some answers?

Which numbers between 2 and 100 can be written as x^y?

> [x^y|x<-[2..100],y<-[2..100],x^y<100]
[4,8,16,32,64,9,27,81,16,64,25,36,49,64,81]

Here we allowed all x and all y as long as x^y<100.

---

Since we’re doing exactly the same to each element, I’d write this in practice using map:

takeOne xs = map (subtract 1) xs

or shorter as

takeOne = map (subtract 1)

(I have to call it subtract 1 because - 1 would be parsed as negative 1.)