Fonction Haskell et fonctions de désassemblage

Question

J'ai les deux fonctions suivantes écrites.

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 

La paire prendra des paires d'éléments et en fabriquera 2-tuples. Si la liste contient un nombre impair d'éléments, ignorez le dernier. Unpair est l'inverse de la paire.

Ceux-ci fonctionnent, mais se demandent s'il existe une façon plus succincte de les écrire.

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

Vous pouvez également abrégez votre définition de pair un peu:

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

Answer 2

Ce n'est pas plus concise, mais par souci de clarté j'utiliser splitEvery de Data.List.Split pour pair:

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

Cela me dépasse: il serait plus agréable de vérifier la longueur de la dernière liste seulement.

Pour unpair j'utiliser foldr pour éviter la récursion explicite:

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

Ceci est juste une question de goût.

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

Bien que je préfère nettement votre définition de pair.

Answer 4

Autant de possibilités. Que penses-tu de ceux-ci?

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

Les deux versions de paire doivent être identiques.

Edit: En ce qui concerne mon commentaire ci-dessus, on peut utiliser le package split de Hackage écrire:

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

qui est plus proche du choix

pair xs = everyOther $ zip xs (tail xs) 

Mais, dans l'esprit de futilité, Je pense que nous devrions probablement tous d'accord sur l'écriture,

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

pour assurer la confusion.

Answer 5

C'est une belle utilisation pour 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])