W dniu 2011-10-16 11:01, f...@g...SKASUJ-TO.pl pisze:
> Piotr Chamera<p...@p...onet.pl> napisał(a):
>
>> (let ((licznik 0))
>> (defun następny () (setf licznik (1+ licznik)))
>> (defun poprzedni () (setf licznik (1- licznik))))
>>
>
> denerwuje mnie to niepowiernie bo nic z tego nie rozumiem,
> np w c funkcja jest definiowana tylko raz i dotego w globalnym
> kontekscie wiec powiedzmy ze to c nie dotyczy
>
> ale czy tam gdzie tego sie uzywa taka funkcje definiuje sie kilka
> razy w roznych kontekstach? czy kazda z nich przechwytuje ten kontekst
> raczej przez referencje czy przez wartosc? czy np jesli jest 5 definicji
> to te wspolne przechwycine dane sa wspolne dla tych definicji?

Przez referencję. W przykładzie powyżej obie funkcje korzystają
z tego samego licznika, bo zostały zdefiniowane w tym samym środowisku
i przechwyciły tą samą zmienną.

CL-USER> (następny)
1
CL-USER> (następny)
2
CL-USER> (poprzedni)
1
CL-USER> (poprzedni)
0
CL-USER> (następny)
1
...

Gdybym napisał to tak:

(let ((licznik 0))
(defun następny () (setf licznik (1+ licznik))))

(let ((licznik 0))
(defun poprzedni () (setf licznik (1- licznik))))

to każda z funkcji miałaby osobny licznik

CL-USER> (następny)
1
CL-USER> (następny)
2
CL-USER> (poprzedni)
-1
CL-USER> (następny)
3
CL-USER> (poprzedni)
-2
...

Mógłbym chcieć też móc ustawiać krok inkrementacji dla obu
liczników jednocześnie i napisać tak:

(let ((krok 1))
(defun krok (x) (setf krok x))

(let ((licznik 0))
(defun następny () (setf licznik (+ licznik krok)))
)

(let ((licznik 0))
(defun poprzedni () (setf licznik (- licznik krok)))
)
)

wtedy krok jest wspólny dla obu funkcji a liczniki oddzielne

CL-USER> (następny)
1
CL-USER> (krok 10)
10
CL-USER> (następny)
11
CL-USER> (poprzedni)
-10
CL-USER> (krok 4)
4
CL-USER> (poprzedni)
-14
CL-USER> (następny)
15
...

W językach takiego typu jak lisp bardzo ważne jest, żeby
przestać utożsamiać funkcję z nazwą, która ją aktualnie
reprezentuje. Nazwy to tylko etykietki dowiązane do obiektów
języka (funkcji, zmiennych itd.) - obiekt może mieć jedną,
wiele lub nie mieć żadnej dowiązanej nazwy.

Można np. napisać to

>> (let ((licznik 0))
>> (defun następny () (setf licznik (1+ licznik)))
>> (defun poprzedni () (setf licznik (1- licznik))))

tak:

(defvar *licz*
(let ((licznik 0))
(list
(lambda ()
(setf licznik (1+ licznik)))
(lambda ()
(setf licznik (1- licznik))))))

taka konstrukcja zwraca listę funkcji (którym nie nadano nazw)

CL-USER> *licz*
(#<COMPILED-LEXICAL-CLOSURE #xC9E7EC6> #<COMPILED-LEXICAL-CLOSURE
#xC9E7E9E>)

i korzystać z licznika tak:

CL-USER> (funcall (first *licz*))
1
CL-USER> (funcall (first *licz*))
2
CL-USER> (funcall (second *licz*))
1
CL-USER> (funcall (second *licz*))
0