# Solved: remove consecutive duplicates

Firstly, understanding the problem is utmost important. Consecutive duplicates in a list occur when the same data point occurs in two or more places in the array, but only if these duplications occur in a row. For example, in the list [1, 2, 2, 3, 2], the ‘2’ data point is duplicated, but it is not considered a consecutive duplication because it is not in a row with the first ‘2’. However, the list [1, 2, 2, 3] does contain a pair of consecutive ‘2’s.

For this issue, Haskell presents a highly flexible, well-optimized solution with its built-in library functions. Particularly, the ‘group’ function from the `Data.List` library would be utilized.

```import Data.List (group)

removeDuplicates :: Eq a => [a] -> [a]
removeDuplicates = map head . group
```

This short, succinct code snippet eliminates consecutive duplicates by dividing the original list into sub-lists of duplicate elements (group), then replacing each sub-list with the first element (map head).

## Understanding the removeDuplicates function

To gain a better understanding of how the code works, let’s break it down.

Importing the necessary library: The code begins with `import Data.List (group)`. Here, we’re importing the ‘group’ function from the ‘Data.List’ library. ‘group’ is a very handy function in Haskell that splits a list into sub-lists of identical, contiguous elements.

Defining the function: We then move to `removeDuplicates :: Eq a => [a] -> [a]`. This is the type declaration for our function. It simply states that our function takes a list of any data type ‘a’ (where ‘a’ is a member of the class ‘Eq’, or can be checked for equality), and will return a list of the same data type.

## Detailed Explanation of Steps

Now, focusing on the part of `removeDuplicates = map head . group`, it is the definition of our function which averages the beauty of Haskell’s functional programming features.

Function composition: The expression uses the ‘.’ operator which in Haskell, means function composition. Basically we’re creating a new function by combining ‘group’ and ‘map head’.

‘group’ function: The function ‘group’ takes our input list and breaks it down into sub-lists where all the identical, contiguous elements are grouped together.

‘map head’ function: Then ‘map head’ goes ahead and replaces each sub-list with the first element of that sub-list – effectively removing all the consecutive duplicates. It’s done in a very efficient way and is readable as well.

This code illustrate how we can effectively use Haskell’s rich library functions and functional programming features to do a lot with a little.