remdups :: (Eq a) => [a] -> [a]
remdups (x : xx : xs) = if x == xx then remdups (x : xs) else x : remdups (xx : xs)

remdups xs = xs

This should cover all cases no?

Also I prefer guards, but I guess that is personal

remdups (x1:x2:xs)

| x1 == x2 = remdups (x2 : xs)

| otherwise = x1 : remdups (x2 : xs)

remdups xs = xs

2009/3/15 R J <rj248842@hotmail.com>

I need to write an implementation using foldl, and a separate implementation using foldr, of a function, "remdups xs", that removes adjacent duplicate items from the list xs. For example, remdups [1,2,2,3,3,3,1,1]= [1,2,3,1].

My approach is first to write a direct recursion, as follows:

   remdups               :: (Eq a) => [a] -> [a]
   remdups []            = []
   remdups (x : [])      = [x]
   remdups (x : xx : xs) = if x == xx then remdups (x : xs) else x : remdups (xx : xs)

This code works, but it has three cases, not usual two, namely [] and (x : xs).

What, if any, is the implementation using only two cases?

Also, if three cases are required, then how can it be implemented using foldr, and how using foldl?

Thanks.

Express your personality in color! Preview and select themes for Hotmail®. See how.

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe