Foognostic blogs Seeking knowledge of foo

More poker with Clojure: what’s in a hand?

Standard disclaimer: Clojure is a new hobby.

In a previous post I wrote some code to create and shuffle a deck of cards. This post demonstrates one way to figure out what a hand is worth according to basic 5 card draw rules.

The implementation is basically one switch statement from a C/Java/Ruby/Groovy/Python perspective. Ruby and Groovy coders will recognize that the return value of the function is the value of the last expression evaluated. So an if statement returns either the value of the true expression or the value of the false expression.

When conditional logic returns values like this, there is no need to use a stack variable to store a return value.

A quick introduction to some of the functions used in the code:

• (if): Aside from returning its true/false expression result, no major difference than Java.
• (cond): Basically a switch statement, returning a value just like (if)
• (let): Defines and initializes "variables" which are immutable.
• #(): This defines an anonymous function. Believe this is a macro for (fn).
• #{}: This defines a set data structure; unordered and no duplicates. Also see the (set). function
• {}: This defines a map data structure, populated with unordered key/value pairs. Bonus: (map key) AND (key map) both return the value for key in a map.

With some minimal descriptions listed, let's dig into the code:

When judging a hand it's critical to know how many of each suit are present AND how many of each value are present. One way to model this is to build histograms for suit and value.

The implementation behind that is not an easy read (probably because it's not great Clojure). Basically this code iterates over the pool of attributes (suits or values) and uses (conj) to aggregate maps into one big map. In the middle a filter function finds all cards matching the current property and then the total number is counted up.

Only one more helper method to go. This method determines whether the hand is a straight, whether all of its cards have consecutive values. The approach taken was a little odd. An array of all possible straight values is built and then segmented into overlapping hands. For example, the first two arrays would be [ace, two, three, four, five] and [two, three, four, five, six]. Each of these possibilities is matched against the hand, using Clojure's facility to compare sets easily.

(some) is a function which returns true when its filter function returns true for any of the collection items it examines.

After all that, here is the hand judging function. It's basically a few local "variables" and a switch statement. Some additional conditional logic appears inside the switch statement as well. This is required to determine whether a hand with three of a kind is a full house (are the remaining cards a pair?).

In the near future all this code will be cleaned up and moved out to BitBucket. Ideally some basic chip tracking and logic would be added so you could actually play poker from a REPL. That's probably much more difficult than it seems, but hopefully this has been useful so far. Please don't hesitate to contact me (goof at foognostic dot net) with any questions!