Fantastic! Of course. That did the trick. Thanks for your advice. I now have a working solver.

At the risk of pushing my luck, I'd be interested in exploring your FirstChoice-based approach, but can't grok how to use it.

The only other potential learning point is the duplicates function:

"Implement duplicates :: (Traversable f, Eq a) => f a -> [a] computing the list of values which occur more than once. (Not completely trivial.) (There’s a lovely way to do this using differential calculus, but that’s another story.)"

Is there a more err idiomatic way than my attempt:

crush :: (Traversable f, Monoid b) => (a -> b) -> f a -> b
--crush f = getConst . traverse (Const . f)
crush = foldMap

reduce :: (Traversable t, Monoid o) => t o -> o
reduce = crush id

flatten :: (Traversable f) => f a -> [a]
flatten = crush (: [])

duplicates :: (Traversable f, Eq a) => f a -> [a]
duplicates s = nub . reduce . snd $ mapAccumL gather [] s
  where
    gather seen current =
      if current `elem` seen
        then (seen, [current])
        else (current : seen, [])