Robert Fey <[EMAIL PROTECTED]> writes:

> Tobias C. Rittweiler wrote:
>
> >Es gibt da zwei gute Papers von K.M. Pitman �ber das Condition System
> >von Common Lisp. Inwiegut sind deine Programmierkentnisse? Falls das
> >keine rhetorische Frage war, kann ich mir mal die Zeit nehmen, um
> >danach zu schauen.
> 
> Sagen wir, ich bin nicht komplett Ahnungslos.
> Ein kleines Tool in c++ ist schon mal schnell geschrieben

Dann bist du ja mit grundlegendem Exception-Handling vertraut.


> aber Lisp kenn ich nur theoretisch. Da schreibt man sich eben mal ne
> neue Sprache die f�r das Problem besser geeignet ist, schreibt massig
> Runtime-Codegenerierende Macros... oder war das woanders? 

Ja, das ist korrekt mit der Metaprogramming Eigenschaft, und dass man
dadurch sehr leicht sogenannte DSLs (Domain Specific Languages) kreieren
kann. Lisp Makros sind jedoch ausschlie�lich compile-time (und sollten
ja nicht mit CPP "Makros" in Verbindung gebracht werden.) 

Aber immerhin ein Fortschritt gegen�ber dem �blicherweise gebrauchten
Stereotyp, das LISP [sic] eine interpretierte, langsame AI Sprache sei,
die schon seit einem Vierteljahrhundert tot sei. :)


> Die Frage war zwar urspr�nglich retorischer Natur aber ich w�rde mich
> dennoch �ber eine nette Abendlekt�re f�rs lange Wochende freuen wenn
> es nicht in Statistik ausartet ;)

I. ``Exceptional Situations In Lisp''

  http://www.nhplace.com/kent/Papers/Exceptional-Situations-1990.html

II. ``Condition Handling in the Lisp Language Family''

  http://www.nhplace.com/kent/Papers/Condition-Handling-2001.html


[Das Minimum, was du an Lisp verstehen solltest, ist

  a) es gib keine artifizielle Unterscheidungs zwischen Statements und
     Expressions; alles gibt einen Wert zur�ck, alles kann �berall
     benutzt werden.  
     Au�erdem wird als Funktioninvokation (func arg1 arg2 ...) anstatt 
     func(arg1, arg2, ...) benutzt. Lisp benutzt also ausschlie�lich
     die Prefix-Notation.  
     
     Siehe auch: 
http://lists.gnu.org/archive/html/gnu-arch-users/2004-08/msg00576.html

  b) man liest Lisp-Programme ein wenig anders als Programme in anderen
     Sprachen: Dies hat damit zu tun, dass nur sehr wenig Semantik in
     extra Syntax transportiert wird (z.B. anstatt eine Zuweisung durch
     `var = <value>' oder `var := <value>' auszudr�cken, geschieht dies
     durch einen "Funktionsausruf" `(setf var <value>)', anstatt durch
     `a[x]' auf ein Array zuzugreifen, geschieht dies durch `(aref a x)'
     --- "Funktionsaufruf" ist zwar eigentlich falsch, aber du kannst es
     konzeptionell erstmal so betrachten.)

     Deswegen musst du aufpassen, dass du nicht den Fehler begehst, auf
     die Klammern zu achten: In C und �hnlichen Sprachen zeigen viele
     Klammern an, dass es sich bei dem Code um etwas kompliziertes
     handelt und man muss jetzt sein Gehirn auf ulta-pendantisch
     schalten. In Lisp schenkst du keine gro�e Aufmerksamkeit darauf.

     Z�hle nie die Klammern nach (insbesondere wenn es viele auf einmal
     am Ende einer Zeile sind), sondern gehe davon aus, dass es die
     richtige Anzahl ist. Um zu erkennen, was wohin geh�rt (und man
     nicht immer nach der entsprechenden (matching) Klammern suchen muss),
     bedient man sich einer speziellen Einr�ckung:

       (f1 foo               ; Argumente von `f1' sind 
           (f2 1 "beispiel") ;   
           bar               ;  1. `foo'
           (f3 a             ;  2. `(f2 ...)'
               b             ;  3. `bar'
               (f4)))        ;  4. `(f3 ...)'

     Siehe auch: 
http://lists.gnu.org/archive/html/gnu-arch-users/2004-08/msg00617.html

  c) Du solltest wissen, was `lambda' ist. Falls du es nicht kennst, ein
     `lambda' Ausdruck kreiert eine anonyme Funktion zur Laufzeit.  In
     Lisp, sowie in allen anderen Sprachen die HOFs (Higher Order
     Functions) unterst�tzen, kann man Funktionen wie Objekte behandeln,
     man kann sie also anderen Funktionen �bergeben, sie als R�ckgabwert
     zur�ckgeben usw.

     Kanonisches Beispiel ist wohl die Funktion MAP, die eine Funktion
     und eine Liste als Argumente hat, und eine neue Liste erstellt,
     wobei die neuen Elemente dadurch gebildet werden, dass die Elemente
     der alten Liste auf die �bergegebene Funktion angewendet worden
     ist: 

       (map add1 (list 1 2 3 4))  
       => (2 3 4 5)
       
       (map (lambda (elem) (* elem elem)) ; anonyme Lambda-Funktion, die
            (list 1 2 3 4))               ; ihr Argument quadriert.
       => (1 4 9 16)
]


--tcr.


--
----------------------------------------------------------------------------
PUG - Penguin User Group Wiesbaden - http://www.pug.org

Antwort per Email an