Lisp-Sprachen nutzen eine sehr minimale Syntax, die nur aus Klammern und Atomen besteht. Lisp verwendet eine sehr einfache Syntax, bei der Code in Form von Listen dargestellt wird. Jede Liste wird durch runde Klammern () umschlossen.
Grundlegende Struktur

<code>
(+ 1 2)  ; Dies ist eine Liste, die eine Operation (Addition) darstellt.
</code>

=====Atome=====

Atome sind die grundlegenden Bausteine in Lisp. Sie können Zahlen, Symbole oder Zeichenfolgen sein.

<code>
42            ; Eine Zahl
'symbol       ; Ein Symbol
"Hello, World" ; Eine Zeichenfolge
</code>

=====Listen und S-Expressions=====

Listen sind die primäre Datenstruktur in Lisp. Eine Liste wird durch Klammern definiert und kann beliebige Elemente enthalten.

<code>
(setq mylist '(1 2 3 4))  ; Definiert eine Liste
(print mylist)            ; Ausgabe: (1 2 3 4)
</code>

S-Expressions sind sowohl Code als auch Daten in Lisp. Der Code ist selbst eine Liste von Ausdrücken.

=====Funktionen=====

In Lisp ist alles eine Funktion, und die meisten Operationen werden durch Funktionen realisiert.
Definieren von Funktionen

<code>
(defun add (a b)
  (+ a b))  ; Definiert eine Funktion, die zwei Zahlen addiert

(add 3 4)  ; Gibt 7 zurück
</code>

=====Bedingte Ausdrücke=====

<code>
(defun check-number (x)
  (cond
    ((> x 0) 'positive)
    ((< x 0) 'negative)
    (t 'zero)))
</code>

=====Schleifen=====

In Lisp werden Schleifen häufig durch rekursive Funktionen ersetzt. Hier ist eine einfache Iteration:

<code>
(defun print-numbers (n)
  (if (zerop n)
      (print "Done!")
      (progn
        (print n)
        (print-numbers (- n 1)))))
</code>

=====Listenmanipulation=====

Lisp bietet viele eingebaute Funktionen zur Manipulation von Listen.
Kopf und Rest der Liste

<code>
(setq mylist '(1 2 3 4))
(car mylist)   ; Gibt 1 zurück (Kopf der Liste)
(cdr mylist)   ; Gibt (2 3 4) zurück (Rest der Liste)
</code>

Anhängen von Elementen

<code>
(setq newlist (append mylist '(5 6)))  ; Gibt (1 2 3 4 5 6) zurück
</code>

=====Makros=====

Lisp bietet eine mächtige Makrosystem, um den Code selbst zu erweitern und zu modifizieren.

<code>
(defmacro unless (condition &body body)
  `(if (not ,condition) 
       (progn ,@body)))
</code>

Verwendung:

<code>
(unless (= 1 2)
  (print "1 ist nicht gleich 2"))
</code>

=====Beispiele=====

Hier sind einige einfache Beispiele für Lisp-Programme:
Fibonacci-Zahlen

<code>
(defun fibonacci (n)
  (if (or (= n 0) (= n 1))
      n
      (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))
</code>

Faktorial

<code>
(defun factorial (n)
  (if (zerop n)
      1
      (* n (factorial (- n 1)))))
</code>