Haskell pair and unpair functions

Question

I have the following two functions written.

pair :: [a] -> [(a, a)]
pair [] = []
pair [x] = []
pair (x1:x2:xs) = (x1, x2) : pair xs

unpair :: [(a, a)] -> [a]
unpair [] = []
unpair ((x1, x2):xs) = x1 : x2 : unpair xs

Pair will take pairs of elements and make 2-tuples of them. If the list has an odd number of elements, discard the last one. Unpair is the reverse of pair.

These work, but wondering whether there is a more succinct way to write these.

Answer 1

One-liners:

pair xs = map snd . filter fst . zip (iterate not True) $ zip xs (drop 1 xs)
unpair = concatMap (\(x,y) -> [x,y])

You could have also abbreviate your definition of pair a little:

pair (x1:x2:xs) = (x1, x2) : pair xs
pair _ = []

Answer 2

It's not any more concise, but for the sake of clarity I'd use splitEvery from Data.List.Split for pair:

pair = map tuplify . filter ((>1) . length) . splitEvery 2
  where
    tuplify [x, y] = (x, y)

This is off the top of my head—it would be nicer to check the length of the last list only.

For unpair I'd use foldr to avoid the explicit recursion:

unpair = foldr (\(x, y) -> (x:) . (y:)) []

This is just a matter of taste.

Answer 3

pair s = dropEven $ zip s (tail s)
     where dropEven s = map fst $ filter snd $ zip s (cycle [True, False])

unpair = concatMap (\(a, b) -> [a, b])

Though I definitely prefer your definition of pair.

Answer 4

So many possibilities. How about these?

unpair' = concatMap (\(x,y) -> [x,y])
pair' xs = map snd . filter fst . zip (cycle [True, False]) $ zip xs (tail xs)
pair'' xs = [(x,y) | (True,x,y) <- zip3 (cycle [True,False]) xs (tail xs)]

The two versions of pair should be the same.

Edit: Regarding my comment above, one can use the split package from Hackage to write:

pair xs = map head . splitEvery 2 $ zip xs (tail xs)

which is closer to the desired

pair xs = everyOther $ zip xs (tail xs)

But, in the spirit of pointlessness, I think we should probably all agree on writing it,

pair = map head . splitEvery 2 . (zip <$> id <*> tail)

to ensure confusion.

Answer 5

This is a nice use for view patterns:

{-# LANGUAGE ViewPatterns #-}

pair :: [a] -> [(a,a)]
pair (splitAt 2 -> ([x,y],ys)) = (x,y) : pair ys
pair _ = []

unpair :: [(a,a)] -> [a]
unpair = (>>= \(x,y) -> [x,y])