Common lisp idiom - is there a better way?

Question

I find myself doing this sort of thing all the time. I've been considering writing a macro/function to make this sort of thing easier, but it occurs to me that I'm probably reinventing the wheel.

Is there an existing function that will let me accomplish this same sort of thing more succinctly?

(defun remove-low-words (word-list)   
  "Return a list with words of insufficient score removed."
  (let ((result nil))
    (dolist (word word-list)  
      (when (good-enough-score-p word) (push word result)))                                      
    result))

Answer 1

There are a couple ways you can do this. First, and probably most easily, you can do it recursively.

(defun remove-low-words (word-list)
  (if (good-enough-score-p (car word-list))
      (list word (remove-low-words (cdr word-list)))
      (remove-low-words (cdr word-list))))

You could also do it with mapcar and reduce, where the former can construct you a list with failing elements replaced by nil and the latter can be used to filter out the nil.

Either would be a good candidate for a "filter" macro or function that takes a list and returns the list filtered by some predicate.

Answer 2

There are several built-in ways of doing this. One way would be:

(remove-if-not 'good-enough-score-p word-list)

And another:

(loop for word in word-list  
      when (good-enough-score-p word)
      collect word)

And yet another:

(mapcan (lambda (word)
          (when (good-enough-score-p word)
            (list word)))
        word-list)

Etc... There's also SERIES and Iterate. The Iterate version is identical to the LOOP version, but the SERIES version is interesting:

(collect (choose-if 'good-enough-score-p (scan word-list))))

So, yes, you're very likely to reinvent some wheel. :-)

Answer 3

In the perl and unix world this is called grep, but it is really just syntax sugar over array iteration. For example, in perl, your solution would look like this:

my @results = grep {good_enough_score_p($_)} @word_list;

The Lisp equivalent is, as mentioned before, a (loop ... when cond collect ...) and/or (remove-if-not cond ...).

You could wrap this up in a function or macro and have a lisp grep (tho its pointless):

(defmacro grep (fn list)
    (let    ((word (intern (format nil "~a" (gensym)))))
        `(loop ;` // I really don't like this syntax hilighter
            for ,word in ,list
            when (funcall ,fn ,word)
            collect ,word)))

or

(defun grep (fn list)
    (remove-if-not fn list))

Answer 4

The function you want is remove-if-not, which is built-in.

(defun remove-low-words (word-list)
  (remove-if-not #'good-enough-score-p word-list))

If you feel like you are re-inventing something to do with lists, you probably are. Check the Hyperspec to see.

• The Hyperspec documentation on remove-if-not
• All sequence functions
• All list-specific functions