How to use foldr correctly in Haskell?

Question

I'm trying to write a function which behave like this:

correctCards :: [Card] -> [Card] -> Int

It takes two lists of type Card and check for how many cards are the same. Here is my code:

correctCards answer guess = foldr step acc guess
        where 
            acc = 0
            step acc guess
                | elem (head guess) answer  = acc + 1
                | otherwise                 = acc

But the types are not match. Can someone tell me where I went wrong? Thanks.

Given the two lists `[A, K, Q]` and `[A, Q, J]` do you expect to return `1` (since only the first positions match) or `2` (since there is a `A` and a `Q` in each list)? — Chris Taylor, Sep 08 '14 at 10:33
I changed "0" to "acc" but it still doesn't work. Do I misuse foldr? Since I'm new in Haskell, and I'm trying to right something like do what a loop does in Java. — user3928256, Sep 08 '14 at 10:39
I would write it as ``correctCards = (length .: intersect) `on` nub``. — Aadit M Shah, Sep 08 '14 at 10:39
@user3928256 even in Java with a loop this would not do what you replied to Chris - in Java you would use something like a Hashset and count the intersection too (as Aadit did — Random Dev, Sep 08 '14 at 10:52
@AaditMShah +1 - but maybe `(.:)` is a bit hard to understand for newbies ;) — Random Dev, Sep 08 '14 at 10:54
@Paul you will find it on hayoo - it's not really a standard operator — Random Dev, Sep 08 '14 at 11:06

score 7 · Accepted Answer · answered Sep 08 '14 at 11:03

Have a look at foldr's type:

foldr :: (a -> b -> b) -> b -> [a] -> b

Now, that means that the function you supply must be of type a -> b -> b. Given the following code:

foldr step 0 cards
-- cards :: [Card]
-- 0     :: Integer
-- step  :: ???

what should the type of step be? Given by our arguments, a should be Card and b should be Integer:

-- concrete type of `foldr` in this case
foldr :: (Card -> Integer -> Integer) -> Integer -> [Card] -> Integer

Therefore, step should have the type (Card -> Integer -> Integer). Compare this to your step function:

step acc guess
    | elem (head guess) answer  = acc + 1
    | otherwise                 = acc

In this case step is Integer -> [Card] -> Integer. And that's not the correct type. Instead, you want

step guess acc
     | elem guess answer = acc + 1
     | otherwise         = acc

Note that step only takes a single, not a whole list.

How to use foldr correctly in Haskell?

1 Answers1

Linked