Linguaggio lisp comune: esiste un modo migliore?

Question

Mi ritrovo a fare questo genere di cose tutto il tempo.Ho preso in considerazione l'idea di scrivere una macro/funzione per rendere questo genere di cose più semplice, ma mi viene in mente che probabilmente sto reinventando la ruota.

Esiste una funzione esistente che mi consentirà di realizzare questo stesso genere di cose in modo più conciso?

(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

Esistono diversi modi integrati per eseguire questa operazione.Un modo sarebbe:

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

E un altro:

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

E ancora un altro:

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

Eccetera...C'è anche SERIE E Iterare.La versione Iterate è identica alla versione LOOP, ma la versione SERIES è interessante:

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

Quindi sì, è molto probabile che ti reinventerai Alcuni ruota.:-)

Answer 2

La funzione che desideri è remove-if-not, che è integrato.

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

Se hai la sensazione di reinventare qualcosa che ha a che fare con le liste, probabilmente è così.Controlla l'Hyperspec per vedere.

• La documentazione Hyperspec su remove-if-not
• Tutte le funzioni di sequenza
• Tutte le funzioni specifiche dell'elenco

Answer 3

Ci sono un paio di modi per farlo.Innanzitutto, e probabilmente più facilmente, puoi farlo in modo ricorsivo.

(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))))

Potresti farlo anche con mapcar E reduce, dove il primo può costruire un elenco con elementi falliti sostituiti da nil e quest'ultimo può essere utilizzato per filtrare il nil.

Entrambi sarebbero un buon candidato per una macro o una funzione "filtro" che accetta un elenco e restituisce l'elenco filtrato da qualche predicato.