Utmost function that takes a comparator function
I agree that this generalization is not particularly useful: to abstract a part of a program to a functional parameter is meaningful when you can reuse that program with a class of different functions, not with two operators like &lt; and &gt;. For this, it is sufficient to define a boolean parameter:

(defun most (fn lst &amp;key lowest)      
 "What's the el of a list with highest or lowest score, according to provided
scoring fn?"
  (if (null lst)
      (values nil nil)    
      (let* ((wins (car lst))                   ; 'wins' is 'winning element'
             (val (funcall fn wins))            ; 'max' is 'winning score'
             (comparison (if lowest #'&lt; #'&gt;))) ; highest or lowest ?
        (dolist (obj (cdr lst))         
          (let ((score (funcall fn obj)))
            (when (funcall comparison score val)
              (setf wins obj
                    val score))))
        (values wins val))))

CL-USER&gt; (most #'length '((a b) (a b a c) (a)))
(A B A C)
4
CL-USER&gt; (most #'length '((a b) (a b a c) (a)) :lowest t)
(A)
1


More, I think that in this case one possibility of generalization could be not on the comparison itself, but on the functional parameter applied to the results, that it the maximum (for which the comparison is used). In fact the Paul Graham's function is the optimization of the following simpler (and less efficient!) function:

(defun most (fn lst)
  (let ((val (reduce #'max lst :key fn)))
    (values (find val lst :key fn) val)))


Abstracting on the function #'max:

(defun most (fn op lst)
  (let ((val (reduce op lst :key fn)))
    (values (find val lst :key fn) val)))


Making it a little more efficient:

(defun most (fn op lst)
  (let* ((vals (mapcar fn lst))
         (val (reduce op vals))
         (wins (position val vals)))
    (values (when wins (nth wins lst)) val)))


But I think that even this generalization is not particularly useful, even if it could have a little more sense:

CL-USER&gt; (most #'length #'max '((a b) (a b a c) (a)))
(A B A C)
4
CL-USER&gt; (most #'length #'min '((a b) (a b a c) (a)))
(A)
1
CL-USER&gt; (defun avg (a b) (/ (+ a b) 2))
AVG
CL-USER&gt; (most #'length #'avg '((a b) (a b a c) (a)))
(A B)
2
CL-USER&gt; (most #'length #'+ '((a b) (a b a c) (a)))
NIL
7