#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