lisp: Aufruf der Lambda Funktion

Interessant, SCNR, meine ersten beiden Lisp Zeilen :-)

Wenn du die Rechenvorschrift bei der Definition der Funktion nicht nicht 
hast:

(defun inc (fn n) (funcall fn n))
(inc #'(lambda(x)(+ x 1)) 10)

Bzw. bei manchen Lisp gleichbedeutend

(defun inc (fn n) (funcall fn n))
(inc (lambda (x) (+ x 1)) 10)

Oder wenn du die Rechenvorschrift bei der Definition von inc hast aber 
noch nicht die Parameter (vgl. dein Pythonfall):

(defun inc (a b) ((lambda(x y)(+ x y)) a b))
(inc 1 10)

Königsklasse dann: Wenn du bei der Definition von inc noch nix hast 
außer der Zahl der Parameter

(defun inc (fn a b) (funcall fn a b))
(inc (lambda(x y)(+ x y)) 1 10)

Die Kaiserklasse dann wenn du auch die Zahl der Parameter nicht kennst. 
Müsste man die Argumentliste abarbeiten bis sie leer ist z.B. über 
Rekursion. Sorry, da steige ich mal aus. ;-)

Tipp für Onlineexperimente
http://www.solve-et-coagula.com/As3Lisp.html

das da ist die Vorschrift, wie die Funktion gebaut wird:

1

(defun inc(n)(lambda(x)(+ x n)))

Wenn du jetzt

1

(inc 10)

aufrufst, liefert es dir eine Funktion, mit der du machen kannst, was du 
willst. z.B.:

1

(setq zippy (inc 10))

2

zippy

3

#<FUNCTION :LAMBDA (X) (+ X N)>

4

(funcall zippy 3)

5

13

Nachtrag: Die Experimente habe ich mit http://gigamonkeys.com/book/ 
Unterstützung gemacht.

Zwie Blum ist Kaiser!

(defun inc(n)(lambda(x)(+ x n)))
((inc 10) 3)

grins und weil's so spassig ist, wie geht das in C++?

Zwie Blum schrieb:
> grins und weil's so spassig ist, wie geht das in C++?


Ich hab leider keinen VC++ 2010 da, der schon lambda Funktionen kann, 
daher kann ich das nicht ausprobieren. Selbst hab ich lamda Funktionen 
in C++ noch nicht benutzt und was ich auf die Schnelle gegoogelt habe 
hat mich nicht wirklich weiter gebracht, als das ich mich trauen würde 
da etwas ungetestet hinzuschreiben.

Ansonsten gehts natürlich immer über einen Funktor, also einer Klasse 
die einen operator() hat

1

class inc

2

{

3

  public:

4

    inc( int n ) : n_( n ) {}

5

    int operator()( int x ) const { return n_ + x; }

6

7

  private:

8

    int n_;

9

};

10

11

int main()

12

{

13

  int j = inc(10)(1);

14

}

@daniel: In SCHEME geht's so, wie du dir das denkst, aber nicht in LISP:

1

> (define (inc n) (lambda(x)(+ x n)))

2

> inc

3

#<procedure:inc>

4

> (inc 10)

5

#<procedure>

6

> ((inc 10) 1)

7

11

Der Grund liegt in dem Unterschied von Lisp-1 und Lisp-2. Scheme ist 
z.B. ein Lisp-1 und Common Lisp ein Lisp-2. Hier die Details:

http://www.dreamsongs.org/Separation.html

(PS: CLisp ist übrigens nicht die Abkürzung für Common Lisp, sondern 
CLisp ist nur eine von vielen Common Lisp Implementierungen, die gut 
portierbar ist und auch unter Windows läuft)