Predicate testing for equality that returns the common element
Soon after I posted this, I went for a walk and realized that this is the perfect opportunity to use reduce. I'm kind of embarrassed that I didn't see it originally, but this was my train of thought that lead me to what I'm much happier with.

First, I tried a simple reduction. This was pretty simple, although still a little verbose:

(defn =?2 [&amp; args]
  (reduce (fn [acc n]
              (if (= n acc)
                n
                (reduced nil)))
          (first args)
          (rest args)))


I decided that this was probably simple enough to use a function macro for. Normally I don't like using them for reductions, but there's not much going on here:

(defn =?3 [&amp; args]
  (reduce #(if (= % %2) % (reduced nil))
          (first args)
          (rest args)))


I don't like using explicit calls to first and rest, as I find they're usually neater when they're implicit in a deconstruction. I decided to deconstruct the arguments instead:

(defn =?4 [&amp; [arg &amp; rest-args]]
  (reduce #(if (= % %2) % (reduced nil))
          arg
          rest-args))


Then I checked what = uses, and found that it just uses multiple argument lists, so I tried that. This strikes me as the more idiomatic solution:

(defn =?5
  ([] nil)
  ([arg] arg)
  ([arg &amp; args]
   (reduce #(if (= % %2) % (reduced nil))
           arg
           args)))


I'm torn between 4 and 5, but I think that both are a significant improvement.