Fusionando dos listas en Haskell

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

Quiero proponer una versión más perezosa de merge:

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

Para un caso de uso de ejemplo, puede consultar una pregunta reciente sobre SO sobre la generación diferida de combinaciones .
La versión en la respuesta aceptada es innecesariamente estricta en el segundo argumento y eso es lo que se mejora aquí.

Entonces, ¿por qué crees que lo simple (concatenación transpuesta) “no es lo suficientemente bonito”? Supongo que has intentado algo como esto:

 merge :: [[a]] -> [a] merge = concat . transpose merge2 :: [a] -> [a] -> [a] merge2 lr = merge [l,r] 

Por lo tanto, puede evitar la recursión explícita (frente a la primera respuesta) y aún así es más simple que la segunda respuesta. ¿Cuáles son los inconvenientes?

EDIT: ¡Echa un vistazo a la respuesta y los comentarios de 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 $ (\xy -> [x,y]) <$> ZipList xs <*> ZipList ys 

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

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