Can you use pattern matching to bind the last element of a list?

Question

Since there is a way to bind the head and tail of a list via pattern matching, I'm wondering if you can use pattern matching to bind the last element of a list?

Answer 1

Yes, you can, using the ViewPatterns extension.

Prelude> :set -XViewPatterns
Prelude> let f (last -> x) = x*2
Prelude> f [1, 2, 3]
6

Note that this pattern will always succeed, though, so you'll probably want to add a pattern for the case where the list is empty, else last will throw an exception.

Prelude> f []
*** Exception: Prelude.last: empty list

Also note that this is just syntactic sugar. Unlike normal pattern matching, this is O(n), since you're still accessing the last element of a singly-linked list. If you need more efficient access, consider using a different data structure such as Data.Sequence, which offers O(1) access to both ends.

Answer 2

You can use ViewPatterns to do pattern matching at the end of a list, so let's do

{-# LANGUAGE ViewPatterns #-}

and use reverse as the viewFunction, because it always succeeds, so for example

printLast :: Show a => IO ()
printLast (reverse -> (x:_)) = print x
printLast _ = putStrLn "Sorry, there wasn't a last element to print."

This is safe in the sense that it doesn't throw any exceptions as long as you covered all the possibilities. (You could rewrite it to return a Maybe, for example.)

The syntax

mainFunction (viewFunction -> pattern) = resultExpression

is syntactic sugar for

mainFunction x = case viewFunction x of pattern -> resultExpression

so you can see it actually just reverses the list then pattern matches that, but it feels nicer. viewFunction is just any function you like. (One of the aims of the extension was to allow people to cleanly and easily use accessor functions for pattern matching so they didn't have to use the underlying structure of their data type when defining functions on it.)

Answer 3

The other answers explain the ViewPatterns-based solutions. If you want to make it more pattern matching-like, you can package that into a PatternSynonym:

tailLast :: [a] -> Maybe ([a], a)
tailLast xs@(_:_) = Just (init xs, last xs)
tailLast _ = Nothing

pattern Split x1 xs xn = x1 : (tailLast -> Just (xs, xn))

and then write your function as e.g.

foo :: [a] -> (a, [a], a)
foo (Split head mid last) = (head, mid, last)
foo _ = error "foo: empty list"

Answer 4

This is my first day of Haskell programming and I also encountered the same issue, but I could not resolve to use some kind of external artifact as suggested in previous solutions.

My feeling about Haskell is that if the core language has no solution for your problem, then the solution is to transform your problem until it works for the language.

In this case transforming the problem means transforming a tail problem into a head problem, which seems the only supported operation in pattern matching. It turns that you can easily do that using a list inversion, then work on the reversed list using head elements as you would use tail elements in the original list, and finally, if necessary, revert the result back to initial order (eg. if it was a list).

For example, given a list of integers (eg. [1,2,3,4,5,6]), assume we want to build this list in which every second element of the original list starting from the end is replaced by its double (exercise taken from Homework1 of this excellent introduction to Haskell) : [2,2,6,4,10,6].

Then we can use the following:

revert :: [Integer] -> [Integer]
revert []     = []
revert (x:[]) = [x]
revert (x:xs) = (revert xs) ++ [x]

doubleSecond :: [Integer] -> [Integer]
doubleSecond []       = []
doubleSecond (x:[])   = [x]
doubleSecond (x:y:xs) = (x:2*y : (doubleSecond xs))

doubleBeforeLast :: [Integer] -> [Integer]
doubleBeforeLast l = ( revert (doubleSecond (revert l)) )

main = putStrLn (show (doubleBeforeLast [1,2,3,4,5,6,7,8,9]))

It's obviously much longer than previous solutions, but it feels more Haskell-ish to me.