#lang racket (define a 5) ; define leagă un nume la o valoare ; apăsați pe Check Syntax și apoi puneți mouse-ul pe variabile (define f (λ (a b) ; λ cu Ctrl-\ (if a b ((λ (a c) (cons a b)) 1 a) ))) ; a și b parametri formali (define fx (lambda (a b) (+ a b))) ; 1 și 2 parametri actuali (fx 1 2) ; punem o parte din cod într-o funcție anonimă, pentru a putea 'salva' valoarea ; întoarsă de (evens (cdr L)), pe care o pasăm ca parametru funcției anonime (define evens (λ (L) (if (null? L) '() ( (λ (evens-cdr) (if (even? (car L)) (cons (car L) evens-cdr) evens-cdr)) (evens (cdr L)))))) ; mai elegant decât mai sus, folosim let pentru a salva valoarea (define evens2 (λ (L) (if (null? L) '() (let ((evens-cdr (evens2 (cdr L)))) (if (even? (car L)) (cons (car L) evens-cdr) evens-cdr)) ))) ; test curs: ; let -- definițiile din let nu sunt vizibile decât abia în corp (define f2 (λ (x y) ; f - 0 apariții; x - 3 apariții; y - 0 apariții (let ((z x) ; z - 1 apariție (x x) ; x - 1 apariție (y x)) ; y - 1 apariție (+ x y z) ))) ; let* -- definiția lui a este vizibilă în definițiile de după (b și c) (define f3 (λ (x y) (let* ((a (+ (* 2 x) (sqrt y))) (b (if (even? a) 1 0)) (c x)) (+ a b c) ))) ; letrec -- definițiile sunt vizibile în întreg letrec-ul ; f este vizibilă inclusiv în în definiția sa (letrec ((f (λ (x y) (if (zero? x) y (f (quotient x 2) (add1 y))))) ) (f 5 0)) ; funcție strictă - (strict #f (/ 5 0)) dă eroare, chiar dacă valoarea ; argumentului nu va fi folosită (define strict (λ (conditie x) (if conditie x #f) )) ; if este funcție nestrictă - (if #f (/ 5 0) 'ceva) nu va da eroare, ; pentru că ramura pentru true nu este evaluată. ; La fel pentru and și or: ;(and #f (/ 5 0)) ;(or #t (/ 5 0)) ; factorial implementat pe stivă ; folosiți Debug, și step pentru a observa cum sunt puse pe stivă apelurile fact-1 (define (fact-1 n) (if (= n 1) 1 (* n (fact-1 (sub1 n))) )) (fact-1 3) ; folosiți Debug pentru a observa cum stiva nu se încarcă cu apeluri fact-aux ; după evaluarea lui (= n 1) cu n=1, întoarcerea se face direct la ieșirea din fact-2 (define (fact-2 n) ; rezultat-partial este produsul numerelor >= n (letrec ((fact-aux (λ (n rezultat-partial) (if (= n 1) rezultat-partial (fact-aux (sub1 n) (* n rezultat-partial)) )))) (fact-aux n 1))) (fact-2 3) ; implementare tail-recursive pentru filtrarea numerelor pare dintr-o listă (define (evens-tail L) (letrec ((evens-aux (λ (L RP) (if (null? L) ; la terminarea recursivității RP ; în RP avem deja rezultatul final (evens-aux (cdr L) ; restul listei ; construim rezultatul parțial (if (even? (car L)) (cons (car L) RP) RP) ))))) (reverse (evens-aux L '())))) ; la final rezultatul întors va fi în ordine inversă ; pentru că primul element par din listă este adăugat cel mai devreme în RP, deci ultimul, ; pentru că celelalte elemente vor fi adăugat mereu la începutul listei ; la recursivitatea pe stivă, primul element par din listă este adăugat cel mai târziu ; (deci primul) în rezultat, după revenirea din recursivitate