"如何在 Haskell 列表的第 n 个元素中设置值？"

Question

I know that xs !! n xs !! n gives me nth element in a list, but I don't know how to edit nth element in that list. Can you tell me how can I edit nth element in a list or give a hint at least?

For example how can I make the second element 'a' an 'e' in this: ['s','t','a','c','k'] ?

Answer 1

Changing the nth element<\/h2>

A common operation in many languages is to assign to an indexed position in an array. In python you might:

This is not just limited to lists however, it will work with any datatype that is an instance of the Traversable<\/a> typeclass.

Answer 2

Because Haskell is a functional language, you cannot 'edit' elements in lists, because everything is immutable. Instead, you can create a new list with something like:

take n xs ++ [newElement] ++ drop (n + 1) xs

Answer 3

You can't edit the nth element of a list, values are immutable. You have to create a new list. But due to the immutability, it can share the part after the changed element with the original list.

So if you want to apply a transformation to the nth element of a list (and have the parts before and after identical), you have three parts

• the front of the list before the element in question, say front
• the element in question, say element
• the back of the list after the element in question, say back .

Then you'd assemble the parts

front ++ transform element : back

so it remains to get a hold on the interesting parts in a nice way.

splitAt :: Int -> [a] -> ([a],[a])

does that, splitAt idx list gives back the first part of the list, before the index idx as the first component of the pair, and the rest as the second, so

changeNthElement :: Int -> (a -> a) -> [a] -> [a]
changeNthElement idx transform list
    | idx < 0   = list
    | otherwise = case spliAt idx list of
                    (front, element:back) -> front ++ transform element : back
                    _ -> list    -- if the list doesn't have an element at index idx

(Note: I have started counting elements at 0, if you want to start counting at 1, you need to adjust and use idx-1 .)

Answer 4

I' surprised the following method was not yet mentioned, so I will add it for further reference:

replace index elem = map (\(index', elem') -> if index' == index then elem else elem') . zip [0..]

> replace 2 'e' "stack"
"steck"

Answer 5

There is also the possibility of writing a simple recursive solution<\/strong> .

changeNthElement :: Int -> (a -> a) -> [a] -> [a]
changeNthElement n fn   []    =  []   -- nothing to change
changeNthElement n fn (x:xs)
    |  (n < 0)    =  x:xs             -- no change for a negative index
    |  (n == 0)   =  (fn x) : xs                          -- easy case
    |  otherwise  =  x : (changeNthElement (n-1) fn xs)   -- recursion