删除List中元素的第二次出现 - Haskell

Question

I'm trying to write a function that deletes the second occurrence of an element in a list. Currently, I've written a function that removes the first element:

    removeFirst _ [] = [] 
    removeFirst a (x:xs) | a == x    = xs
                          | otherwise = x : removeFirst a xs

as a starting point. However,I'm not sure this function can be accomplished with list comprehension. Is there a way to implement this using map?

EDIT: Now I have added a removeSecond function which calls the first

    deleteSecond :: Eq a => a -> [a] -> [a]
    deleteSecond _ [] = []
    deleteSecond a (x:xs) | x==a = removeFirst a xs
                  | otherwise = x:removeSecond a xs

However now the list that is returned removes the first AND second occurrence of an element.

Answer 1

Well, assuming you've got removeFirst - how about searching for the first occurence, and then using removeFirst on the remaining list?

removeSecond :: Eq a => a -> [a] -> [a]
removeSecond _ [] = []
removeSecond a (x:xs) | x==a = x:removeFirst a xs
                      | otherwise = x:removeSecond a xs

Answer 2

You could also implement this as a fold.

removeNth :: Eq a => Int -> a -> [a] -> [a]
removeNth n a = concatMap snd . scanl go (0,[])
  where go (m,_) b | a /= b    = (m,   [b])
                   | n /= m    = (m+1, [b])
                   | otherwise = (m+1, [])

and in action:

λ removeNth 0 1 [1,2,3,1]
[2,3,1]
λ removeNth 1 1 [1,2,3,1]
[1,2,3]

I used scanl rather than foldl or foldr so it could both pass state left-to-right and work on infinite lists:

λ take 11 . removeNth 3 'a' $ cycle "abc"
"abcabcabcbc"

Answer 3

Here is an instinctive implementation using functions provided by List :

import List (elemIndices);
removeSecond x xs = case elemIndices x xs of
        (_:i:_) -> (take i xs) ++ (drop (i+1) xs)
        _ -> xs

removeNth n x xs = let indies = elemIndices x xs
                   in if length indies < n
                      then xs
                      else let idx = indies !! (n-1)
                           in (take idx xs) ++ (drop (idx+1) xs)

Note: This one cannot handle infinite list, and its performance may not be good for very large list.