Par Haskell y funciones de desvinculación

Question

Tengo las siguientes dos funciones escritas.

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 

El par tomará pares de elementos y hará 2-tuplas de ellos. Si la lista tiene un número impar de elementos, descartar el último. Desvincular es el reverso del par.

Estos funcionan, pero se preguntan si hay una forma más concisa de escribirlos.

Answer 1

de una sola línea:

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

Usted podría tener también abreviar su definición de pair un poco:

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

Answer 2

No es más concisa, pero en aras de la claridad que haría uso splitEvery de Data.List.Split para pair:

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

Esto está fuera de mi cabeza, sería mejor comprobar únicamente la longitud de la última lista.

Para unpair que haría uso de foldr para evitar la recursión explícita:

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

Esto es sólo una cuestión de gusto.

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]) 

Aunque definitivamente prefiero su definición de pair.

Answer 4

Tantas posibilidades. ¿Que tal esto?

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)] 

Las dos versiones del par deben ser iguales.

Editar: En cuanto a mi comentario anterior, se puede utilizar el paquete de separación de Hackage escribir:

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

que está más cerca de la

deseada

pair xs = everyOther $ zip xs (tail xs) 

Pero, en el espíritu de inutilidad, Creo que probablemente todos deberíamos estar de acuerdo en escribirlo,

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

para asegurar confusión.

Answer 5

Este es un uso agradable para 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])