how to add a number in a 2D list with specific index in haskell

Question

I'm beginner in haskell and I tried to add a number in a 2D list with specific index in haskell but I don't know how to do

example i have this:

[[],[],[]]

and I would like to put a number (3) in the index 1 like this

[[],[3],[]]

I tried this

[array !! 1] ++ [[3]]

but it doesn't work

Answer 1

As paul mentions, things in Haskell are immutable. What you want to do must be done not be modifying the list in place, but by destructuring the list, transforming one of its parts, and restructuring the list with this changed part. One way of destructuring (via splitAt) is put forth there; I'd like to offer another.

Lists in Haskell are defined as follows:

data [] a = [] | a : [a]

This reads "A list of a is either empty or an a followed by a list of a". (:) is pronounced "cons" for "constructor", and with it, you can create nonempty lists.

1 : []            -> [1]
1 : [2,3]         -> [1,2,3]
1 : 2 : 3 : []    -> [1,2,3]

This goes both ways, thanks to pattern matching. If you have a list [1,2,3], matching it to x : xs will bind its head 1 to the name x and its tail [2,3] to xs. As you can see, we've destructured the list into the two pieces that were initially used to create it. We can then operate on those pieces before putting the list back together:

λ> let x : xs = [1,2,3]
λ> let y = x - 5
λ> y : xs
 [-4,2,3]

So in your case, we can match the initial list to x : y : z : [], compute w = y ++ [3], and construct our new list:

λ> let x : y : z : [] = [[],[],[]]
λ> let w = y ++ [3]
λ> [x,w,z]
 [[],[3],[]]

But that's not very extensible, and it doesn't solve the problem you pose ("with specific index"). What if later on we want to change the thousandth item of a list? I'm not too keen on matching that many pieces. Fortunately, we know a little something about lists—index n in list xs is index n+1 in list x:xs. So we can recurse, moving one step along the list and decrementing our index each step of the way:

foo :: Int -> [[Int]] -> [[Int]]
foo 0 (x:xs) = TODO    -- Index 0 is x. We have arrived; here, we concatenate with [3] before restructuring the list.
foo n (x:xs) = x : foo (n-1) xs
foo n []     = TODO    -- Up to you how you would like to handle invalid indices. Consider the function error.

Implement the first of those three yourself, assuming you're operating on index zero. Make sure you understand the recursive call in the second. Then read on.

Now, this works. It's not all that useful, though—it performs a predetermined computation on a specified item in a list of one particular type. It's time to generalize. What we want is a function of the following type signature:

bar :: (a -> a) -> Int -> [a] -> [a]

where bar f n xs applies the transformation f to the value at index n in the list xs. With this, we can implement the function from before:

foo n xs = bar (++[3]) n xs
foo = bar (++[3])    -- Alternatively, with partial application

And believe it or not, changing the foo you already wrote into the much more useful bar is a very simple task. Give it a try!

Answer 2

As you may have noticed in your foray so far, Haskell isn't like many other languages in that it is generally immutable, so trying to change a value, especially in a deeply nested structure like that, isn't the easiest thing. [array !! 1] would give you a nested list [[]] but this is not mutable, so any manipulations you do this structure won't be reflected in the original array, it'll be a separate copy.

(There are specialized environments where you can do local mutability, as with e.g. Vectors in the ST monad, but these are an exception.)

For what you're trying to do, you'll have to deconstruct the list to get it to a point where you can easily make the modification, then reconstruct the final structure from the (modified) parts.

The splitAt function looks like it will help you with this: it takes a list and separates it into two parts at the index you give it.

let array = [[],[],[]]
splitAt 1 array

will give you

([[]], [[],[]])

This helps you by getting you closer to the list you want, the middle nested list.

Let's do a destructuring bind to be able to reconstruct your final list later:

let array = [[],[],[]]
    (beginning, end) = splitAt 1 array

Next, you'll need to get at the sub-list you want, which is the first item in the end list:

    desired = head end

Now you can make your modification -- note, this will produce a new list, it won't modify the one that's there:

    desired' = 3:desired

Now we need to put this back into the end list. Unfortunately, the end list is still the original value of [[],[]], so we'll have to replace the head of this with our desired' to make it right:

    end' = desired' : (tail end)

This drops the empty sub-list at the beginning and affixes the modified list in its place.

Now all that's left is to recombine the modified end' with the original beginning:

in beginning ++ end'

making the whole snippet:

let array = [[],[],[]]
    (beginning, end) = splitAt 1 array
    desired = head end
    desired' = 3:desired
    end' = desired' : (tail end)
in beginning ++ end'

or, if you're entering all these as commands in the REPL:

let array = [[],[],[]]
let (beginning, end) = splitAt 1 array
let desired = head end
let desired' = 3:desired
let end' = desired' : (tail end)
beginning ++ end'