Question

Consider the following problem: given a list of length three of tuples (String,Int), is there a pair of elements having the same “Int” part? (For example, [("bob",5),("gertrude",3),("al",5)] contains such a pair, but [("bob",5),("gertrude",3),("al",1)] does not.)

This is how I would implement such a function:

import Data.List (sortBy)
import Data.Function (on)

hasPair::[(String,Int)]->Bool
hasPair = napkin . sortBy (compare `on` snd)
  where napkin [(_, a),(_, b),(_, c)] | a == b = True
                                      | b == c = True
                                      | otherwise = False

I’ve used pattern matching to bind names to the “Int” part of the tuples, but I want to sort first (in order to group like members), so I’ve put the pattern-matching function inside a where clause. But this brings me to my question: what’s a good strategy for picking names for functions that live inside where clauses? I want to be able to think of such names quickly. For this example, “hasPair” seems like a good choice, but it’s already taken! I find that pattern comes up a lot – the natural-seeming name for a helper function is already taken by the outer function that calls it. So I have, at times, called such helper functions things like “op”, “foo”, and even “helper” – here I have chosen “napkin” to emphasize its use-it-once, throw-it-away nature.

So, dear Stackoverflow readers, what would you have called “napkin”? And more importantly, how do you approach this issue in general?

Answer 1

General rules for locally-scoped variable naming.

• f , k, g, h for super simple local, semi-anonymous things
• go for (tail) recursive helpers (precedent)
• n , m, i, j for length and size and other numeric values
• v for results of map lookups and other dictionary types
• s and t for strings.
• a:as and x:xs and y:ys for lists.
• (a,b,c,_) for tuple fields.

These generally only apply for arguments to HOFs. For your case, I’d go with something like k or eq3.

Use apostrophes sparingly, for derived values.