lisp filtrer les résultats de la liste ne correspond pas à prédicat

Je suis en train d'apprendre lisp, en utilisant emacs dialecte et j'ai une question.
disons liste a certains membres, pour lesquels le prédicat renvoie la valeur false. comment puis-je créer une nouvelle liste de ces membres? quelque chose comme { A in L: p(A) is true }. en python, il est fonction de filtre, est-il quelque chose d'équivalent en lisp? si non, comment dois-je faire?

Grâce

InformationsquelleAutor Anycorn | 2010-02-10
  1. 43

    Ces fonctions sont dans la CL paquet, vous devrez (require 'cl) les utiliser:

    (remove-if-not #'evenp '(1 2 3 4 5))

    Cela retourne une nouvelle liste avec tous les nombres pairs de l'argument.

    Aussi regarder delete-if-not, qui fait de même, mais modifie sa liste d'arguments.

    • Je tiens à souligner que la fonction #'remove-if-not sont déconseillés en Common Lisp1 où le filtre devra être écrite (remove-if (complement #'evenp) '(1 2 3 4 5)) ou tout simplement (remove-if #'oddp '(1 2 3 4 5)) — la fonction complement n'existe pas dans Emacs Lisp, à ma connaissance, cependant.
    • Pls utiliser cl-lib le paquet, et utiliser cl-supprimer-si-non la fonction de remplacement.
    InformationsquelleAutor rootzlevel
  2. 21

    Si vous manipuler les listes lourdement dans votre code, veuillez utiliser tableau de bord.el moderne fonctionnelle de la programmation de la bibliothèque, au lieu d'écrire du code réutilisable et à réinventer la roue. Il a toutes les fonctions pour travailler avec des listes, les arbres, la fonction de l'application et le contrôle de flux que vous pouvez imaginer. Pour conserver tous les éléments qui correspondent à un prédicat et d'en supprimer d'autres vous avez besoin filtre:

    (-filter (lambda (x) (> x 2)) '(1 2 3 4 5)) ; (3 4 5)

    Autres fonctions d'intérêt sont -supprimer, -prendre-while, -drop-while:

    (-remove (lambda (x) (> x 2)) '(1 2 3 4 5)) ; (1 2)    
(-take-while (lambda (x) (< x 3)) '(1 2 3 2 1)) ; (1 2)
(-drop-while (lambda (x) (< x 3)) '(1 2 3 2 1)) ; (3 2 1)

    Ce qui est formidable à propos de dash.el est qu'il prend en charge anaphoric macros. Anaphoric les macros se comportent comme des fonctions, mais ils permettent une syntaxe spéciale pour rendre le code plus concis. Au lieu de fournir un fonction anonyme comme argument, il suffit d'écrire un s-expression et l'utilisation it au lieu d'une variable locale, comme x dans les exemples précédents. Correspondant anaphoric macros commencer avec 2 tirets au lieu d'un:

    (--filter (> it 2) '(1 2 3 4 5)) ; (3 4 5)
(--remove (> it 2) '(1 2 3 4 5)) ; (1 2)
(--take-while (< it 3) '(1 2 3 2 1)) ; (1 2)
(--drop-while (< it 3) '(1 2 3 2 1)) ; (3 2 1)
    InformationsquelleAutor Mirzhan Irkegulov
  3. 19

    Je cherchais la même nuit dernière et est venu à travers la Elisp Livre De Recettes sur EmacsWiki. La section sur les Listes/Séquences contient filtrage teqniques et de montrer comment cela peut être fait avec mapcar et delq. J'ai du mod le code pour l'utiliser pour mes propres fins, mais voici l'original:

    ;; Emacs Lisp doesn’t come with a ‘filter’ function to keep elements that satisfy 
;; a conditional and excise the elements that do not satisfy it. One can use ‘mapcar’ 
;; to iterate over a list with a conditional, and then use ‘delq’ to remove the ‘nil’  
;; values.

   (defun my-filter (condp lst)
     (delq nil
           (mapcar (lambda (x) (and (funcall condp x) x)) lst)))

;; Therefore

  (my-filter 'identity my-list)

;; is equivalent to

  (delq nil my-list)

;; For example:

  (let ((num-list '(1 'a 2 "nil" 3 nil 4)))
    (my-filter 'numberp num-list))   ==> (1 2 3 4)

;; Actually the package cl-seq contains the functions remove-if and remove-if-not. 
;; The latter can be used instead of my-filter.
    InformationsquelleAutor kjfletch
  4. 5

    Emacs est désormais livré avec la bibliothèque seq.el, utilisez seq-remove.

    seq-remove (pred sequence) 
"Return a list of all the elements for which (PRED element) is nil in SEQUENCE."
    InformationsquelleAutor Joelmob
  5. 1

    Avec common lisp, vous pouvez implémenter la fonction comme suit:

    (defun my-filter  (f args)
    (cond ((null args) nil)
        ((if (funcall f (car args))
            (cons (car args) (my-filter  f (cdr args)))
            (my-filter  f (cdr args))))))

(print 
      (my-filter #'evenp '(1 2 3 4 5)))
    InformationsquelleAutor prosseek
  6. 1

    Il ya une tonne de façons de filtrer ou de sélectionner quelque chose à partir d'une liste à l'aide de built-ins qui sont beaucoup plus rapides que les boucles. Le haut-supprimer-si peut être utilisé de cette façon. Par exemple, supposons que je souhaite supprimer les éléments 3 à 10 dans la liste Maliste. Exécutez le code suivant comme exemple:

    (let ((MyList (number-sequence 0 9))
      (Index -1)
      )
  (remove-if #'(lambda (Elt)
                  (setq Index (1+ Index))
                  (and (>= Index 3) (<= Index 5))
                  )
              MyList
           )
 )

    Vous obtiendrez '(0 1 2 6 7 8 9).

    Supposons que vous voulez pour ne garder que les éléments entre 3 et 5. En gros, vous retournez la condition que j'ai écrit ci-dessus dans le prédicat.

    (let ((MyList (number-sequence 0 9))
      (Index -1)
      )
  (remove-if #'(lambda (Elt)
                   (setq Index (1+ Index))
                   (or (< Index 3) (> Index 5))
                  )
              MyList
           )
 )

    Vous obtiendrez '(3 4 5)

    Vous pouvez utiliser ce que vous avez besoin pour le prédicat que vous devez fournir à supprimer-si. La seule limite est votre imagination à propos de quoi l'utiliser. Vous pouvez utiliser la séquence des fonctions de filtrage, mais vous n'en avez pas besoin.

    Sinon, vous pouvez également utiliser mapcar ou mapcar* faire une boucle sur une liste à l'aide d'une fonction qui transforme des entrées spécifiques à néant et l'utilisation (supprimer-si nul ...) pour y déposer nils.

    InformationsquelleAutor Pablo A Perez-Fernandez
  7. 0

    Il est surprenant qu'il n'y a pas builtin version de filtre sans cl ou (ou seq ce qui est très nouveau).

    La mise en œuvre de filter mentionnés ici (que vous voyez dans la Elisp livre de recettes et d'ailleurs) est incorrect. Il utilise nil comme un marqueur pour les éléments à supprimer, ce qui signifie que si vous avez nils dans votre liste pour commencer, ils vont être supprimée, même si elles satisfont le prédicat.

    Pour corriger cette mise en œuvre, le nil marqueurs doivent être remplacés par un uninterred symbole (ie. gensym).

    (defun my-filter (pred list)
  (let ((DELMARKER (make-symbol "DEL")))
    (delq
      DELMARKER
      (mapcar (lambda (x) (if (funcall pred x) x DELMARKER))
              list))))
    InformationsquelleAutor pyrocrasty