Praca nad listą list w Haskell

Question

Jestem trochę początkującym dla Haskella, więc walczę trochę z rzeczami ścisłymi, zastanawiając się, czy ktoś może mi pomóc z funkcją, którą próbuję zbudować . Zasadniczo przyjmuje wykaz list, na przykład:

[[1,2,3], [7,6,8], [0,3,4]] 

i dodaje je razem w jednej listy tłumacząc później list od liczby stanowisk po to jest. Więc praca na liście Przykładem może to być rzeczywiście robi coś takiego:

foldl (zipWith +) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]] 

Oto mój bieżącej funkcji (która dostaje typu błędy):

addLists :: [[Integer]] -> [Integer] 
    addLists [[]] = [] 
    addLists [[x]] = [x] 
    addLists [x:xs] = zipWith (+) [x] ([0]++ (addLists xs)) 

Answer 1

myślę, że robi to, co chcesz

import Data.List (transpose) 

addLists :: Num a => [[a]] -> [a] 
addLists xs = map sum . transpose $ zipWith (\n x -> replicate n 0 ++ x) [0..] xs 

Answer 2

Pamiętaj, że ([0]++) to to samo, co (0:), które sprawi, że będzie wyglądać bardziej porządnie i zaoszczędzi nam nanosekundę lub dwie. (Żartuję z nanosekundową rzeczą - nikt nie jest w stanie powiedzieć, że coś jest o nanosekundę szybsze, ale w ten sposób jest jeszcze przyjemniejsze.)

Zastanówmy się najpierw nad stworzeniem potrzebnych list. Chcemy

postponeLists [[1,2,3], [7,6,8], [10,20,30,40]] 
      = [[1,2,3], [0,7,6,8], [0,0,10,20,30,40]] 
      = [1,2,3] : ones that should have zero in front of them 

To wystarczy informacja o definicji:

postponeLists [] = [] 
postponeLists (l:ls) = l : map (0:) (postponeLists ls) 

Teraz wspomnianego

foldl (zipWith +) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]] 

ale znaczy

foldl (zipWith (+)) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]] 

ale niestety, że daje [] ponieważ zipWith przestaje działać, gdy na jednej z list zabraknie elementów. Potrzebujemy sposobu na skompresowanie ich, aby się nie zatrzymał.

Rozwiązanie 1: znaleźć najdłuższy, uczynić z nich wszystko, co maxlength użyciu take maxlength.(++ repeat 0)
Rozwiązanie 2: napisać inną funkcję zipWith to nie przeszkadza.

wolę rozwiązania 2. Spójrzmy na definition of zipWith

zipWith :: (a->b->c) -> [a]->[b]->[c] 
zipWith f (a:as) (b:bs) = f a b : zipWith f as bs 
zipWith _ _  _  = [] -- here's the problem - it stops as soon as any list is empty 

OK, niech nie zatrzyma wtedy:

zipWithMore :: (a -> a -> a) -> [a] -> [a] -> [a] 
zipWithMore f (a:as) (b:bs) = f a b : zipWithMore f as bs 
zipWithMore f []  bs  = bs -- if there's more in bs, use that 
zipWithMore f as  []  = as -- if there's more in as, use that 

Teraz można zastąpić zipWith (+) z zipWithMore (+). Opuszczę ci punchline.