#lang racket

; apăsați pe Check Syntax și apoi puneți mouse-ul pe variabile
(define f (λ (a b) ; λ cu Ctrl-\
            (if a
                b
                ( (λ (a b) (cons (length a) b)) 1 a)
                )))

 
(define f3 (λ (a) (+ a 4)))

(map f3 '(1 2 3 4))


(define fstrict (λ (a b) (list a))) ; funcțiile definite cu define sunt stricte

; (fstrict 'a (/ 5 0)) ; eroare pentru că argumentul al doilea este calculat chiar dacă nenecesar

(if #t 'a (/ 5 0)) ; if funcție nestrictă - împărțirea nu este calculată.


(require racket/trace)

(define (fact-1 n)
  (if (zero? n) 1
      (* n (fact-1 (sub1 n)))
      ))

(trace fact-1)
(fact-1 3)


(display "-------------\n")

(define (fact-aux n rezultat-partial)
  (if (= n 1)
      rezultat-partial ; acum rezultat final
      (fact-aux (sub1 n) (* n rezultat-partial))
      ))

(define (fact-2 n)
  (fact-aux n 1))

(trace fact-2)
(trace fact-aux)
(fact-2 5)

(untrace fact-1)
(fact-1 4)




(define f1 (λ (a b)
             (if a
                 b
                 ( (λ (a b) (cons a b)) 1 a)
                 )))


(f1 1 2)




(define nume 'valoare)

(lambda (nume) 'corp)



(define evens2 (λ (L)
                 (if (null? L)
                     '()
                     (append
                      (if (even? (car L)) (list (car L)) null)
                      (evens2 (cdr L)))
                     )))


(define evens
  (λ (L)
    (if (null? L)
        '()
        (if (even? (car L))
            (cons (car L) (evens (cdr L)))
            (evens (cdr L))
            ))))


; legare cu lambda

((lambda (a b) 'corp) 1 2)
; în această aplicare, lambda va lega pe a și b la 1 respectiv 2

(define evensL
  (λ (L)
    (if (null? L)
        '()
        ((lambda (evensCdrL) ; leagă numele evensCdrL la valoarea pe care este aplicată funcția
           (if (even? (car L))
               (cons (car L) evensCdrL)
               evensCdrL
               ))
         (evensL (cdr L)) ; aceasta este valoarea la care se leagă evensCdrL
         )
        )))


; legare cu let

;(let (listă de legări) corp) ; lista de legări este o listă de expresii (nume valoare)
(let ( (a 1)
       (b 2)
       )
  (+ a b))


(define evensLet
  (λ (L)
    (if (null? L)
        '()
        (let ((evensCdrL  (evensLet (cdr L)))) ; leagă numele evensCdrL la rezultatul apelului recursiv
          (if (even? (car L))
              (cons (car L) evensCdrL)
              evensCdrL
              )
          )
        )
    ))

(let* ( (a 1)
        (b 2)
        (c (evensL (list a b)))  ; c este '(2)
        (d (length c)) ; d este 1
        )
  (> d 2)
  )

; echivalent cu:
(let ( (a 1)
       (b 2)
       )
  (let ((c (evensL (list a b))))
    (let ((d (length c)))
      (> d 2)
      )))

(letrec ((fact (λ (n) (if (zero? n) 1 (* n (fact (sub1 n)))))))
  (fact 10))


; named let, echivalent cu letrec anterior
(let fact ((n 10)) ; perechi (nume-parametru-formal valoare-apel), rezultatul lui let va fi (fact valoare-apel)
  (if (zero? n) 1 (* n (fact (sub1 n))))
  )

(let factT ((n 10) (rezP 1))  ; inițial se apelează (factT 10 1)
  (if (zero? n) rezP (factT (sub1 n) (* rezP n)))
  )