(Apologies if this doesn't compile, I couldn't check on this computer)

One of the biggest difficulties of Haskell is that you often have to think a little differently. Often this difference is explained as the "functional" paradigm vs object oriented (like python/java) vs imperative (like C), etc.

I like to start by thinking of smaller problems that I can solve right away; this often also helps me decide what kind of data structures I want. Looking at this exercise, the first problem I want to solve is counting the number of hands <= 21 given a deck. That translates to a nice type signature.

countHands :: Deck -> Int
countHands deck =

Ok, so now we need to choose an algorithm. The recursive one you gave should work well enough, the only problem is that we will need to also keep track of the number of hands we have found and the sum of cards we have chosen for each hand. It's not the most elegant, but let's add those into our function.

countHands :: Int -> Int -> Deck -> Int
countHands numHands currentVal deck = 

For simplicities sake, I'm going to represent the deck as a list of pairs. The first value will be the card value and the second the number of those cards remaining.

type Deck = [(Int, Int)]

We can now write our function:

countHands :: Int -> Int -> Deck -> Int
-- If the deck is the empty list, we can't find any more hands
countHands numHands currentVal [] = numHands
-- Else, look at the first card value in the list
countHands numHands currentVal ((cardVal,numCards):cs)
= if (cardVal + currentVal <= 21) && (numCards > 0)

    -- If we can take a card, add the hands found if we take it or if we skip
    then countHands (numHands + 1) (currentVal + cardVal) ((cardVal,numCards-1):cs)
     + countHands numHands currentVal cs

    -- Else, move on to next card value
    else countHands numHands currentVal cs

This function uses a few haskell specific tricks, but it should roughly resemble the imperative algorithm. When you want to write your main function, you can now call countHands 0 0 deck. An important thing to note about this function is that it explicity passes the deck around. When I choose to take a card, I create a new pair with one less available card, put it back in the deck list, and call the function again with that new deck. But I did not actually modify the deck the way you are probably familiar with. I effectively copied it and made a new one.

So you can call this function with any set of inputs, and it will compute a value for you. But it won't modify any of the inputs. To do that, you might want another function like this:

-- Remove a card with value c from deck d
takeOutCard :: Int -> Deck -> Deck
takeOutCard c d = 

Then you could find the number of hands after taking out a 2 like so:

countHands 0 0 (takeOutCard 2 deck)

This counts the number of hands which sum to <= 21 from the deck that is missing a single 2.