# Solved: last element of list

In the realm of Haskell programming, handling lists forms a fundamental part. Lists are of crucial importance since they allow us to store multiple items of the same type. When working with lists, often, it is necessary to fetch the last element. While it may seem straightforward, this operation requires a good understanding of how Haskell implements lists. In this article, we delve into detail about fetching the last element in a list using Haskell.

One approach to fetch the last element of a list is using the classic recursive method, which makes Haskell a popular functional programming choice. The basic idea is to traverse the list till we reach the end, and then return that element. This operation is achievable thanks to the patterns available in Haskell and tail recursion. Consider the following Haskell code snippet:

```lastElem :: [a] -> a
lastElem [x] = x
lastElem (_:xs) = lastElem xs
```

In this code, we define a function named ‘lastElem’ that fetches the last element in a list. The function makes use of pattern matching for two scenarios: when the list contains only one element, and when the list has more than one element. In the second scenario, it calls itself recursively until it reaches the last element.

## Understanding The Function

In the Haskell snippet provided above, the function `lastElem` utilizes pattern matching to deal with the two scenarios. Pattern matching in Haskell is a way to check the data against certain forms and perform actions based on the form it matches.

At the core of this approach lies the ‘(_:xs)’ pattern. It allows the function to handle any list with more than one element through recursion. The underscore (_) serves as a wild-card that ignores the current head of the list and the function is called again with the rest of the list (xs).

## Deeper look at Recursive Solution

The true beauty of this function lies in its recursive nature. To traverse the list, it calls itself, again and again, chopping off the head element of the list until only one element is left. Once that happens, it matches the ‘[x]’ pattern and returns that single element. This forms the entire premise of getting to the last element in a list.

While this method is neat and works well for most cases, it could crash if called with an empty list. This is because our function does not handle the scenario where the list is empty.

## Handling Empty Lists

We can improve our ‘lastElem’ function by adding a condition to handle the empty list. We can use the ‘Maybe’ data type in Haskell, which allows us to represent optional values. Here’s an example:

```lastElem :: [a] -> Maybe a
lastElem [] = Nothing
lastElem [x] = Just x
lastElem (_:xs) = lastElem xs
```

In this modified function, if an empty list is passed, it will return ‘Nothing’. For a list with elements, it will return ‘Just x’, where ‘x’ is the last element of the list.

In summary, dealing with lists is elementary in functional programming, but it requires a good understanding of the language’s constructs. The example described in this article provides an overview of how to fetch the last element of a list, leveraging pattern matching and recursion in Haskell.

Related posts: