No se puede averiguar cómo combinar 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]
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)