2.5.1. Listen

Listen sind in Lisp allgegenwärtig. Sie werden durch runde Klammern ( und ) begrenzt. Zwischen diesen Klammern befinden sich die Elemente dieser Liste.

  • Semantik einer Liste

    Listen können unterschiedliche Bedeutungen (Semantiken) haben. Sie können Daten darstellen oder eine ausführbare Prozedur bezeichnen.

;;; Listen als Daten:

(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)

(Dasom Clemens Miki Ronak Robin Arevik Francesco Nicolas Daniel Lydia Yan)

((Pauline Oliveiros) (Luigi Nono) (Helmut Lachenmann) (Beatriz Ferreira))

((c fis cis) (g es) (a gis))

;;; Listen als Prozeduren

(expt 2 3)

(print "hallo peng")

(list 'a 'b "hallo" 3 5 1)

  • Evaluation

    Bei der Evaluation einer nicht leeren Liste erwartet das Lisp System als erstes Element eine Funktion, ein Makro oder eine special form, die jeweils angeben, wie die übrigen Elemente der Liste ausgewertet werden sollen.

  • Quotierung

    Wenn eine Liste als eine Liste von Daten behandelt werden soll, kann man mit einem einfachen Anführungszeichen ' unmittelbar vor der öffnenden Klammer die Auswerung der Liste verhindern. Man nennt eine solche Liste mit vorangestelltem Anführungszeichen eine quotierte Liste.

;;; Auswertung einer nicht quotierten Liste, deren erstes Element
;;; weder ein Funktionsname, noch ein Makroname, noch eine special
;;; form ist:

(1 2 3 4 5) ;; -> illegal function call

;;; Verhinderung der Auswertung durch Quotierung:

'(1 2 3 4 5) ;; -> (1 2 3 4 5)

  • Leere Liste

    Listen dürfen in Lisp auch gar kein Element enthalten. Eine Liste ohne Elemente nennt man leere Liste. Eine leere Liste wird in Common Lisp mit den folgenden, gleichbedeutenden Zeichenfolgen dargestellt: (), '() bzw. NIL 2: Eine leere Liste evaluiert zu sich selbst und ist daher im Unterschied zu Listen mit mindestens einem Element ein Atom. Die leere Liste bzw. das Symbol NIL spielt zudem in Common Lisp eine wichtige Sonderrolle, da es zugleich den boolschen Wahrheitswert "falsch" bezeichnet.

;;; Leere Liste

'() ;; -> nil
NIL ;; -> nil
()  ;; -> nil

;;; leere Listen sind Atome!

(atom '())  ;; -> t
(atom '(1)) ;; -> nil

Listen werden intern repräsentiert durch cons Zellen. Eine einfache Zelle zeigt die Abb.

Abbildung 2.1. Eine einfache cons Zelle

cons01

Es handelt sich um zwei Boxen, die Zeiger auf beliebige Elemente enthalten. Die Funktion cons erzeugt eine neue Cons Zelle und liefert diese Zelle bei Evaluation als Wert des Funktionsaufrufs zurück. Die Funktion erwartet zwei Argumente. Sie entsprechen den Werten, auf die die beiden Zeiger der cons Zelle zeigen sollen.

Bei einer Liste mit einem Element zeigt der Zeiger in der linken Box auf das erste Element der Liste und der Zeiger in der rechten Box auf nil:

Abbildung 2.2. Eine Liste mit einem Element

cons02

Diese Grafik ist also ein Modell der internen Repräsentation des folgenden Lisp Ausdrucks:

(cons 3 nil) -> (3)

Ist das zweite Argument von cons eine nicht leere Liste, so evaluiert der Funktionsaufruf zu einer Liste, bei der die Liste des zweiten Arguments der cons Form vorne um das erste Argument erweitert wird.

(cons 2 '(3)) -> (2 3)

Dieser Ausdruck lässt sich durch Substitution des zweiten Arguments der cons Form durch die vorhergehende Form als ein verschachtelter Aufruf zweiter Aufrufe von cons darstellen:

     (cons 2 '(3))         -> (2 3)

<=>  (cons 2 (cons 3 nil)) -> (2 3)

Eine Darstellung des Modells dieser Form zeigt die nachstehende Abbildung.

Abbildung 2.3. Eine Liste mit zwei Elementen

cons03

Dies lässt sich natürlich erweitern. Eine Liste mit drei Elementen lässt sich also mit folgendem Lisp Ausdruck erzeugen:

    (cons 1 '(2 3)) -> (1 2 3)

<=> (cons 1 (cons 2 '(3))) -> (1 2 3)

<=> (cons 1 (cons 2 (cons 3 nil))) -> (1 2 3)

Die Darstellung des internen Modells ist dann:

Abbildung 2.4. Eine Liste mit drei Elementen

cons04

Auch verschachtelte Listen können so erzeugt werden:

     (cons '(1 2) '(3)) -> ((1 2) 3)

 <=> (cons '(1 2) (cons 3 nil)) -> ((1 2) 3)

 <=> (cons (cons 1 (cons 2 nil)) (cons 3 nil)) -> ((1 2) 3)

Das interne Modell geht aus der folgenden Abbildung hervor:

Abbildung 2.5. Eine verschachtelte Liste

cons05

Aufgabe: Zeichne das Boxdiagramm der Liste '​(​(​1 2)(3 4)(5 6​)​).

Um das zu erreichen, ermittele zuerst die Lisp Form, die zu dieser Liste evaluiert und die ausschließlich verschachtelte Aufrufe von cons Formen enthält, deren Argumente entweder Zahlen, andere cons Formen oder nil sind (d.h. die keine quotierten Listen enthalten). Beginne dabei zunächst mit einem Ausdruck mit quotierten Listen und ersetze diese sukzessive durch cons Formen, die als Argumente lediglich Zahlen oder nil enthalten.

    ;;; Der Anfangsterm lautet:

    (cons '(1 2) '((3 4) (5 6))) -> ((1 2) (3 4) (5 6))

    (cons (cons 1 (cons 2 nil)) (cons '(3 4) '((5 6))))

    (cons (cons 1 (cons 2 nil)) (cons (cons 3 (cons 4 nil)) (cons (cons 5 (cons 6 nil)) nil)))

Zusätzlicher Source Code von Johannes Quint (noch nicht eingearbeitet):

       (* 3 4 5)
       (if (< 3 5) 'kleiner 'groesser)
       '(1 2 3 4)

       ;      list-Funktionen:
       ;      list, append, reverse, length, first, rest, butlast, last, member, nth

       ;      list erzeugt eine Liste
       (list 1 2 3)

       ;      vgl.
       (1 2 3) ; => ERROR

       ;      Symbole muessen quotiert werden, um vor der Evaluierung bewahrt zu werden:
       (list 1 'zwei "drei")

       ;      vgl.
       '(1 zwei "drei")

       ;      Backquote und Komma:
       `(,(- 2 1) zwei "drei")

       ;      vgl.
       `((- 2 1) zwei "drei")

       ;      andere Listenfunktionen
       (append '(1 2 3) '(4 5 6))
       (reverse '(1 2 3))
       (length '(1 2 3))
       (first '(1 2 3))
       (rest '(1 2 3))
       (butlast '(1 2 3))
       (last '(1 2 3)) ; !!! Scheme: => 3, CommonLisp: => (3) !!!
       (nth '(1 2 3) 1) ; !!! CommonLisp: (nth 1 '(1 2 3)) !!!
       (member 2 '(1 2 3))
       (member 4 '(1 2 3))

       ;;     Random

       ;      Random-Funktionen
       ;      random, between, pick, shuffle, odds, vary

       (random 3)
       (random 3.0)
       (between 10 20)
       (+ (random 10) 10)
       (shuffle '(1 2 3 4 5 6))
       (pick '(1 2 3 4 5 6))
       (between 10.0 20)

       (odds 0.2 "unwahrscheinlich" "wahrscheinlich")

       (vary 10 0.1)                           ; weicht von 10 um max 10% (= 1) ab

       ;;     Mapping

       ;      Mapping-Funktionen
       ;      key, note, rhythm, rescale, interp, scale-order

       (key '(df4 c5 df5 af5))
       (note '(61 72 73 68))
       (rhythm '(s q h))
       (rescale 2 1 3 400 600)
       (interp 4 '(0 0 8 100))
       (scale-order '(1 5 3 2 6 0 7))

       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;; 2\. Variablen
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

       ;;     global: define
       ;;     !!! COMMONLISP defvar !!!

       (define var (random 10.0))

       (list var (* var 10)(- var 1))

       var

       ;;     local: let / let*

       (let ((var (random 10.0)))
         (list var (* var 10)(- var 1)))

       (let* ((var (random 10.0))(var1 (* var 10))(var2 (- var 1)))
         (list var var1 var2))

       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;; 3\. Funktionen
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

       ;;     define
       ;;     !!! COMMONLISP: defun !!!

       (define (average a b)
         (/ (+ a b) 2))

       (average 9 11)

       (define (malvier x) (* x 4))
       (malvier 5)

       ;;     keyword-Argumente
       ;;     [ !!! COMMONLISP: &optional bzw. &key !!! ]
       ;;     define* statt define erlaubt optionale und keyword-Argumente

       (define* (func name (adjectiv "guter"))
         (string-append name " war ein " adjectiv " Komponist"))

       (func "Beethoven")
       (func "Stockhausen" "rheinischer")

       (define* (ton time (pitch "c4")(duration "quarter")(loudness "soft")(instrument "piano"))
         (list time pitch duration loudness instrument))
       (ton 0)
       (ton 0 :instrument "oboe")
       (defun ton (time &key (pitch 60) (duration 1) (amplitude 0.5)(instrument "piano"))
           (list time pitch duration amplitude instrument))
       (ton 0 :duration 3 :instrument "viola")

       ;;    rest-Argumente
       ;;    !!! COMMONLISP: &rest !!!

       (define (order . numbers)
         (scale-order numbers))

       (order 1 4 2 5 4 1 7 4 3 10 22 1 333)

; => ERROR

       ;      Quotation

       'a
;;; Einfuehrung: Sexpr Variablen Funktionen

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Referenz:
;;; Heinrich Taube, Notes from the Metalevel, Kapitel 2-6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; 0\. Oberflaeche:
;;;    Console und Textfiles

;      Programme werden auf Textfiles geschrieben
;      Evtl. Textausgabe erfolgt in der Console
;      Zu Tastaturbefehlen siehe im Menu:
;      -> Help -> Code Editor
;      Die Syntax 'Sal' werden wir im Kurs nicht beruecksichtigen

;;;    Documentatiom
;;;    Notes from the Metalevel
2: NIL ist ein Akronym für Nothing In List. ↩

results matching ""

    No results matching ""