Question

I have a list of integers, I need to append elements to it at different times.

let xs =[]::[Int]

usually appending elements to this would be like:

1:xs

but when using IO in a function, it doesn’t seem to work within a do block and gives errors, and

let xs = [1]
let xs=(2:xs)

results in an infinite list like [1,2,2,2,2,…..]
What can I do to correct this?

Answer 1

You seem to have a fundamental misunderstanding about lists in Haskell. The lists are always immutable, so there is no way to add new elements to an existing list. I.e. You can only create new lists.

So, accordingly, the a:b operator never adds an element to a list, but creates a new list where a is the first element, which is followed by the existing list b.

When you say:

let xs = 2 : xs

You are saying that xs is a list where the first element is 2 and the rest of the list is xs itself, which logically results in an infinite list of 2’s. In the context of this question, it’s irrelevant whether you are in the IO monad or not.

So given the above, you need to do something like

let xs1 = [1]
let xs2 = 2:xs1
let xs3 = 3:xs2

But of course, this is the same as simply doing

let xs3 = [3,2,1]

So you really need to give some more context on what kind of list you want to build and why.