4.1.1. Datentypen

Die Datentypen in Lisp lassen sich in zwei Klassen einteilen:

4.1.1.1. Atom

Atome sind Ausdrücke, die nicht weiter unterteilbar sind und die zu sich selbst evaluieren ("deren Wert sie selbst sind"). Hierzu zählen

• Zahlen

;;     Integer (ganze Zahlen), Floats (Kommazahlen), Ratios (Brüche)

1
1.1
1/2

;;;      Mathematische-Funktionen:
;;;      mod, min, max, expt, log, round, floor, abs

(+ 1 1)
(+ 1 (- 3 2))
(mod 4 3) ; Rest
(log (expt 2 (round (* 1.3 (floor  (min 3 2.6))))) 2)

• Boolean (wahr oder falsch)

  Die Werte wahr und falsch werden in Common Lisp durch T und NIL dargestellt. Sie sind von großer Bedeutung in Lisp und es existieren viele Funktionen, die einen dieser Werte zurückliefern. Als Anwender ist es auch häufig sinnvoll, in Programmen selbst solche Funktionen zu definieren. Sie werden analog zum gleichen Begriff in der Aussagenlogik Prädikat (englisch 'predicate') genannt. Hier einige Beispiele für Prädikate:

;      Tests
;      =, >, <, >=, <=, evenp, oddp,

(= 4/5 0.8) ;; -> NIL !
(= (float 4/5) 0.8) ;; -> T
(>= 5/6 0.8) ;; -> T

;;; Test für gerade/ungerade

(evenp 3) ;; -> NIL
(oddp 3) ;; -> T

;;; Test für Datentypen

(numberp 4) ;; -> T
(numberp "Helmut") ;; -> NIL
(stringp "Helmut") ;; -> T
(atom "Helmut") ;; -> T
(atom 'Hallo) ;; -> T
(atom '(1 2 3)) ;; -> NIL

• Zeichenketten (Strings)

  Zeichenketten bestehen aus beliebigen Zeichen, die von Apostrophen eingerahmt werden. Soll ein solches Apostroph Bestandteil der Zeichenkette sein, so muss das Zeichen \ unmittelbar davor geschrieben werden. Dieser Schrägstrich rückwärts wird bei einer formatierten Ausgabe in eine Textdatei oder in die REPL nicht ausgedruckt. Ein expliziter Schrägstrich rückwärts wird innerhalb einer Zeichenkette durch zwei unmittelbar aufeinanderfolgende Schrägstriche rückwärts bezeichnet.

"Helmut Lachenmann"

"ein \"Zitat\" innerhalb einer Zeichenkette"

"Ein Schrägstrich geht so: \\"

;;; formatierte Ausgabe in die REPL:

(format t "~a" "ein \"Zitat\" innerhalb einer Zeichenkette")

• Symbole

  Symbole sind Zeichenketten, die mit einem beliebigen Charakter ausser einer Zahl oder den Zeichen ", ' oder # beginnen und anschließend beliebig viele Zeichen (mit Ausnahme von sogenannten 'white-space-characters', wie Leerzeichen, Zeilenwechseln oder Tab-Zeichen) enthalten.

;;; gültige Symbole

a
ein-symbol
noch-0-+*-ein-Symbol
_und-noch123-eins_

;;; keine Symbole:

1hallo ;;; beginnt mit einer Zahl
#hallo ;;; beginnt mit dem Zeichen #
"hallo ;;; wird als unvollständige Zeichenkette gelesen

4.1.1.2. S-Expression

Eine S-Expression (symbolic expression, abgekürzt auch sexpr) ist ein zusammengesetzer Ausdruck. Hierzu zählen alle Ausdrücke, die als Liste dargestellt werden, das heisst Ausdrücke, die von runden Klammern eingerahmt werden. Listen sind ein wesentliches Charakteristikum aller Lisp Dialekte (der Name Lisp steht für LISt Processing). Semantisch können Listen grob ausgedrückt drei unterschiedliche Funktionen erfüllen:

• Daten

  Daten sind semantisch eher passive Komponenten, die der Speicherung von Informationen in verschiedenster Formen dienen.

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

'(Youngju Andrés Miki Elias Richard Camilo Amir Ioannis Junsun Juan Hanyu Raphaël)

'((Helmut Lachenmann) (Luigi Nono) (Karlheinz Stockhausen) (Salvatore Sciarrino))

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

• Funktionsaufrufe

  Funktionsaufrufe sind im Unterschied zu Daten aktive Teile eines Programms, die dazu dienen können, Daten zu erzeugen, zu transformieren oder irgendwelche Prozesse in Gang zu setzen, wie beispielsweise das Drucken von Informationen oder allgemeinen grafischen Darstellungen auf dem Bildschirm, das Lesen oder Erzeugen von Dateien oder auch das Erzeugen bzw. Abspielen von Klängen.

(* 7 3 4) ;; -> 84

(print "Hallo Welt") ;; -> "Hallo Welt"

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

• special forms bzw. macro forms

  special forms sind spezielle syntaktische Konstrukte, die die Strukturierung von Programmabläufen ermöglichen, die sich nicht über Funktionsaufrufe realisieren lassen. Bei Common Lisp sind es Listen, die mit folgenden Symbolen beginnen: block, catch, eval-when, flet, function, go, if, labels, let*, let, load-time-value, locally, macrolet, multiple-value-call, multiple-value-prog1, progn, progv, quote, return-from, setq, symbol-macrolet, tagbody, the, throw und unwind-protect.

(if (< 4 5) 'kleiner 'groesser) ;;; -> kleiner

(let ((i 3)) i) ;;; -> 3

 Ähnlich wie special forms ermöglichen macro forms (oder
'Makros') spezielle syntaktische Konstrukte. Bei Makros handelt
es sich um Definitionen, wie Listen in andere Listen
transformiert und dann evaluiert werden. Neben vielen bereits
von Common Lisp bereitgestellten Makros ermöglicht das Makro
"defmacro" auch die Definition eigener Makros und damit die
Erweiterung der Sprache Common Lisp durch neue syntaktische
Formen.

(cond
  ((< 2 1) 'kleiner)
  ((> 2 1) 'groesser)
  (t 'gleich)) ;; -> groesser

(defun square (x) (* x x)) -> square

• Listen

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