Counting the total value of Card instances given
First a minor note. It is less efficient to create a temporary Array from the result of Zip2. You can use the function map instead of the method map:

map(Zip2(hand, dropFirst(hand))) { ... }.reduce(0, +)


Second, I believe that having such a complex comment describing what your method does, is a sign that your code can be much more understandable. Usually a good replacement for a comment is a well named function. This is how I would implement your function:

func countHand(hand: [Card]) -&gt; Int {
    func iterateTwoCardsAtATime(hand: [Card], block: (first: Card, second: Card) -&gt; ()) {
        for (first, second) in Zip2(hand, dropFirst(hand)) {
            block(first: first, second: second)
        }
    }

    func scoreForConsecutiveCards(first: Card, second: Card) -&gt; Int {
        switch(first.suit, first.rank, second.rank) {
            case (.Hearts, _, .Num(let numRank)) where numRank % 2 == 1:
                return 2 * numRank
            case (.Diamonds, .Num(5), .Ace):
                return 100
            default:
                return 0
        }
    }

    var sum = 0
    iterateTwoCardsAtATime(hand) { (first, second) in
        sum += scoreForConsecutiveCards(first, second)
    }
    return sum
}


Yes, this is definitely more verbose, but the code is much more clear and doesn't require a comment.

First, a new developer looks at the method and sees that there is a function called iterateTwoCardsAtATime. If they want to verify that it works as expected, they can, but most can assume it works and skip that implementation.

Then they get to scoreForConsecutiveCards. This contains all of the complicated scoring logic which is probably the biggest concern when evaluating this method. It is well contained and distinct from the other logic of the method. The other logic is very utilitarian while this logic is important business logic.

Finally, there is a simple understandable block of code written in English like language to sum up the results of all of the scores.

With modern IDEs with features like code folding, clarity is way more important than brevity.