How to detect the end of a list in Haskell?

Question

I'm writting a recursive function that use specific formulas to calculate 2 lists. But I will simplify the function so you can understand the problem I'm having because the point here is to detect [] of the list.

So I've the following code:

listSum::([Integer],[Integer])->Double
listSum ((x:xs),(y:ys)) 
    | ((x:xs),(y:ys))==(x:[],y:[])=0.0
    | otherwise = (((fromIntegral x)::Double)+((fromIntegral y)::Double)) + listSum ((xs),(ys))

Output I'm having right now

listSum([1,2],[1,2])
2.0

listSum([1],[1])
0.0

listSum([],[])
*** Exception: file.hs: .....: Non-exhaustive patterns in function ListSum

And the output I wish to have

listSum([1,2],[1,2])
6.0

listSum([1],[1])
2.0

listSum([],[])
0.0

What did I miss? Or did I write too much?

you detect the end of a list by pattern-matching on `[]` (e.g. `myFunc [] = 0; myFunc (x:xs) = x + myFunc xs`) — genisage, Feb 21 '15 at 05:46
The first thing to do is to tell GHC `-fwarn-incomplete-patterns`. — dfeuer, Feb 21 '15 at 05:47

score 3 · Accepted Answer · edited May 23 '17 at 12:28

3

You don't need the first guard in your function. You can simply write it as the following (I just dropped ::Double because Haskell can infer it)

listSum :: ([Integer], [Integer]) -> Double
listSum ([], []) = 0.0
listSum ((x:xs),(y:ys)) = fromIntegral x + fromIntegral y + listSum (xs, ys)

Now, whenever the arguments passed to listSum are empty lists, the result will be 0.0, otherwise the recursive function will be called.

Note: The above function will work only if both the lists are of equal size. Otherwise, you need to write it like this

listSum::([Integer],[Integer])->Double
listSum ([], []) = 0.0
listSum ((x:xs), []) = fromIntegral x + listSum(xs, [])
listSum ([], (y:ys)) = fromIntegral y + listSum(ys, [])
listSum ((x:xs),(y:ys)) = fromIntegral x + fromIntegral y + listSum (xs, ys)

Note: Even simpler, the entire code can be written, as suggested by Rein Henrichs, like this

pairwiseSum xs ys = sum (zipWith (+) xs ys)

edited May 23 '17 at 12:28

Community

1
1

answered Feb 21 '15 at 05:46

thefourtheye

233,700
52
457
497

1

This still has incomplete patterns! – dfeuer Feb 21 '15 at 05:46
@dfeuer I think in OP's case both the lists will be of equal size. – thefourtheye Feb 21 '15 at 05:48
Yes, in my case, both lists are equal size. Thank you thefourtheye, really nice explanation. It works. – Lord Rixuel Feb 21 '15 at 05:49
@dfeuer Okay, I am missing something then. Can you please give an example? – thefourtheye Feb 21 '15 at 05:50
@thefourtheye, I just mean that incomplete patterns are bad, even if you think they'll never cause a problem. May I suggest you nix all the `::Double` annotations? GHC can infer all those by itself. – dfeuer Feb 21 '15 at 05:52
As an alternative solution that handles lists of unequal size in a reasonable way, `pairwiseSum xs ys = sum (zipWith (+) xs ys)`. – Rein Henrichs Feb 21 '15 at 06:30
@ReinHenrichs Thanks :-) Included that suggestion in the answer. – thefourtheye Feb 21 '15 at 07:22
(or just `pairwiseSum = (sum .) . zipWith (+)`) – Dogbert Feb 21 '15 at 08:42
1

@Dogbert I specifically avoided that pointfree version because it reduces readability for no gain. It's a perfect example of pointless pointfree. – Rein Henrichs Feb 21 '15 at 22:20

How to detect the end of a list in Haskell?

1 Answers1