La fusión de dos listas en Haskell

Question

No se puede encontrar la manera de fusionar dos listas de la siguiente manera en 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: Tome un vistazo a los comentarios de respuesta y Ed'ka !

Otra posibilidad:

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

O, si te gusta Aplicativo:

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

Answer 3

Entonces, ¿por qué cree que sencilla (. Concat transponer) "no es lo suficientemente bonita"? Asumo que has probado algo como:

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

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

De este modo se puede evitar una recursión explícita (vs la primera respuesta) y todavía es más simple que la segunda respuesta. ¿Cuáles son los inconvenientes?

Answer 4

quiero proponer una versión más perezoso de fusión:

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

Para un caso de ejemplo, el uso se puede comprobar una reciente Así que la pregunta acerca lazy generation of combinations.
La versión en la respuesta aceptada es innecesariamente estricta en el segundo argumento y eso es lo que se mejora aquí.

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

Sin duda, un caso para un Despliegue:

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