#lang racket



(lambda (a b) ; niște variabile a și b
  (list 5
        (lambda (a b) ; alte variabile a și b
          (cons a b) ; a și b din λ interior
          )
        a ; a din λ exterior
        b ; b din λ exterior
        ))

(define evens
  (λ (L)
    (cond
      [(null? L) null]
      [(even? (car L))
       (cons (car L) (evens (cdr L)))]
      [else (evens (cdr L))]
      )))
(evens '(1 2 3 4 5 6 7 8))


; exemplu legare folosind lambda:
; punem o parte din cod într-o funcție anonimă, pentru a putea 'salva' valorile
;  întoarse de (car L) și de (evens (cdr L)), pe care le pasăm ca parametru funcției
;  anonime
(define evens2
  (λ (L)
    ((λ (primul-element rezultat-rest)
       (cond ; exact codul de mai sus, dar folosim valorile legate
         [(null? L) null]
         [(even? primul-element)
          (cons primul-element rezultat-rest)]
         [else rezultat-rest]
         ))
     (if (null? L) #f (car L)) ; primul element, dacă lista e nevidă
     (if (null? L) #f (evens2 (cdr L))) ; apel recursiv, dacă lista e nevidă
     )))
(evens2 '(1 2 3 4 5 6 7 8))

; aceeași legare, dar folosind let (+ verific lista vidă înainte)
(define evens3
  (λ (L)
    (if (null? L) null
        (let [
              (primul-element (car L))
              (rezultat-rest (evens3 (cdr L)))
              ]
          (cond
            [(even? primul-element) 
             (cons primul-element rezultat-rest)]
            [else rezultat-rest]
            )))))
(evens3 '(1 2 3 4 5 6 7 8))

; atenție la variabilele cu același nume
(let [(a 1)
      (b 2)
      ]
  (let [(a ; o nouă variabilă a
         (+ a 1)) ; a deja vizibil în exteriorul let-ului
        ]
    (+ a b)
    ))

; același cod, dar folosim un calcul mai detaliat let*
(define evens4
  (λ (L)
    (if (null? L) null
        (let* [
               (primul-element (car L))
               (restul-listei (cdr L))
               (rezultat-rest (evens4 restul-listei))
               ]
          (cond
            [(even? primul-element) 
             (cons primul-element rezultat-rest)]
            [else rezultat-rest]
            )))))
(evens4 '(1 2 3 4 5 6 7 8))

; definire **locală** a lui evens, și apel în corpul lui letrec
(letrec [(evens5
          (λ (L)
            (cond
              [(null? L) null]
              [(even? (car L))
               (cons (car L) (evens5 (cdr L)))]
              [else (evens5 (cdr L))]
              )))]
  (evens5 '(1 2 3 4 5 6 7 8))
  )
; aici nu mai este vizibil evens5

; definire **locală** a lui evens **și** apel în aceeași construcție
(let evens [(L '(1 2 3 4 5 6 7 8))] ; exprim că
  ; parametrul funcției se numește L
  ; **și** că unicul apel al lui evens se va face pe valoarea dată (lista 1, 2, 3..)
  (cond
    [(null? L) null]
    [(even? (car L))
     (cons (car L) (evens (cdr L)))]
    [else (evens (cdr L))]
    ))

; let-values
(display '--------)(newline)
(let-values [([a b] (split-at '(1 2 3 4 5 6 7 8) 4))
             ]
  (display a)
  (display b)
  )
(newline)
 
; pot întoarce mai multe valori cu values
(define (sum-prod a b)
  (values (+ a b) (* a b)))
(sum-prod 5 6)