Die Funktionen where und wherever

In diesem Kapitel möchte ich zwei Funktionen vorstellen, die für viele Zwecke sehr gut zu gebrauchen sind. (whereever ...) geht eine Liste durch und wendet eine lambda-expression auf jedes Listenelement an. In der Ergebnisliste werden nur die Elemente gesammelt, bei denen die lambda-expression ein True zurückgegeben hat (also alles andere als nil).

Ein Hinweis: Sollten Probleme im Umgang mit lambda-expressions vorhanden sein, empfehle ich erst einmal das entsprechende Kapitel zu lesen.

Die Funktion selbst ist nicht kompliziert, hier der Code (die Funktion ist nicht rekursiv, da sie die Listen nur auf einer Ebene bearbeitet):

(defun whereever(liste expr / )
  (apply'append
    (mapcar
    '(lambda(v / )(if((eval expr)v)(list v)))
      liste
    )
  )
)

Ein Hinweis: In Visual Lisp gibt es neuerdings die Funktionen (vl-remove-if ...) und (vl-remove-if-not ...), die genau das tun, was unser (whereever ...) auch macht. Anwendungsbeispiele:

Reduzieren einer Zahlenliste auf diejenigen Zahlen, die größer als 4 sind:

(whereever
 '(5 1 2 7 4 5 3 8)
 '(lambda(v)(> v 4))
)
    = > (5 7 5 8)

Im nächsten Beispiel werden aus einer Liste mit einzelnen Buchstaben diejenigen herausgesucht, die kleingeschrieben sind.

(whereever
 '("A" "c" "F" "u" "w" "N")
 '(lambda(v)(>(ascii v)88))
)
    => ("c" "u" "w")

Und in diesem Beispiel werden aus einer Liste mit Punkten diejenigen herausgefiltert, deren Z-Wert ungleich 0 ist:

(whereever punkteliste
 '(lambda(p)(/=(caddr p)0.0))
)

Als letztes Anwendungsbeispiel hier noch eine Funktionsdefinition zum Auslesen aller Stützpunkte einer LWPOLYLINE:

(defun get-lwpoly-vtcs(lwpoly-data / )
  (whereever lwpoly-data
   '(lambda(dxfval / )(=(car dxfval)10))
  )
)

; Achtung! Nicht verwenden!
(defun where(liste expr / )
  (car(whereever liste expr))
)

Das wäre sicherlich nicht falsch, würde immer ein korrektes Ergebnis liefern, aber es wäre einfach eine nicht praxisgerechte Definition! Schließlich arbeitet whereever ja immer die ganze Liste ab. where würde dann abgesehen, vom ersten Element, die ganze geleistete Arbeit wieder verwerfen! Wir würden hier also unsinnige Rechenzeiten verursachen.

Da wir für (where ...) also einen Verarbeitungsprozess brauchen, der sich unterbrechen lässt, greifen wir hier auf eine Konstruktion mit (while ...) zurück, da sich while-Schleifen jederzeit abbrechen lassen. Trotz der zu (whereever ...) ähnlichen Arbeitsweise kommt also ein ganz anderer Ansatz zum Tragen:

(defun where(liste expr / )
  (while
    (and liste
      (not((eval expr)(car liste)))
    )
    (setq liste(cdr liste))
  )
  (car liste)
)

Das folgende Beispiel sucht in einer Liste die erste Zahl, die größer als 5 ist:

(where
 '(0 2 5 3 8 7 0 3 1 4 2 6 1)
 '(lambda(v)(> v 5))
)
    =>  8

Und dieses Beispiel findet in einer Liste mit Punkten den ersten Punkt, bei dem X, Y und Z gleich sind:

(where
 '((4 2 3)(1 8 4)(6 3 0)(3 3 3)(5 2 6))
 '(lambda(p)(=(car p)(cadr p)(caddr p)))
)

Die Technik, auf diesem Wege (Verkürzen um jeweils den car) Listen zu bearbeiten, wird den meisten AutoLisp-Programmierern vertraut sein. Im Kapitel über (mapcdr ...) werden wir auf ähnliche Techniken noch einmal zurückkommen.