La fusion de deux listes dans Haskell

Question

ne peux pas comprendre comment fusionner deux listes de la manière suivante dans Haskell:

INPUT: [1,2,3,4,5] [11,12,13,14] 

OUTPUT: [1,11,2,12,3,13,4,14,5] 

Answer 1

merge :: [a] -> [a] -> [a] 
merge xs  []  = xs 
merge []  ys  = ys 
merge (x:xs) (y:ys) = x : y : merge xs ys 

Answer 2

EDIT: Jetez un oeil à la réponse et les commentaires de Ed'ka !

Une autre possibilité:

merge xs ys = concatMap (\(x,y) -> [x,y]) (zip xs ys) 

Ou, si vous aimez Applicative:

merge xs ys = concat $ getZipList $ (\x y -> [x,y]) <$> ZipList xs <*> ZipList ys 

Answer 3

Alors, pourquoi pensez-vous que simple (. Concat transposent) "est pas assez jolie"? Je suppose que vous avez essayé quelque chose comme:

merge :: [[a]] -> [a] 
merge = concat . transpose 

merge2 :: [a] -> [a] -> [a] 
merge2 l r = merge [l,r] 

Ainsi vous pouvez éviter la récursivité explicite (vs la première réponse) et encore il est plus simple que la deuxième réponse. Alors, quels sont les inconvénients?

Answer 4

Je veux proposer une version de fusion paresseuses:

merge [] ys = ys 
merge (x:xs) ys = x:merge ys xs 

Pour un exemple de cas d'utilisation, vous pouvez vérifier une récente question au sujet de SO lazy generation of combinations.
La version dans la réponse acceptée est inutilement stricte dans le second argument et c'est ce qui est amélioré ici.

Answer 5

-- ++ 
pp [] [] = [] 
pp [] (h:t) = h:pp [] t 
pp (h:t) [] = h:pp t [] 
pp (h:t) (a:b) = h : pp t (a:b) 

Answer 6

Sûrement un cas pour un dépliage:

interleave :: [a] -> [a] -> [a] 
interleave = curry $ unfoldr g 
    where 
    g ([], []) = Nothing 
    g ([], (y:ys)) = Just (y, (ys, [])) 
    g (x:xs, ys) = Just (x, (ys, xs))