#lang racket

(define y 5)

(
 (λ(x)
   (λ(x) x))
 y)


; echivalent define de ami sus:
((λ (y) ; leg y când funcția este aplicată
   ( ; aplic asupra lui y
    (λ(x)
      (λ(x) x))
    y)
   )
 5)

; ( (λ (x) (x x))  (λ (x) (x x))  ) ; ruleaza la infinit

; ((λ (x y) x) 5 (  (λ (x) (x x))  (λ (x) (x x))  )) ; evaluare aplicativă -> nu rulează la infinit

(λ (x) (λ (x) (x x))  (λ (x) (x x))  ) ; închid omega într-o funcție, va fi evaluat doar dacă apelez funcția




; funcționale

; uncurry
(+ 2 3) ; aplicare uncurry

(define (curry+ x) ; + ca funcție curry
  (λ (y) (+ x y)))

; curry
((curry+ 1) 2) ; aplicare funcție curry


(map (λ (x) (+ x 1)) '(1 2 3 4 5)) ; incrementarea unei liste, cu funcție anonimă

(map + '(1 2 3 4 5) '(6 7 8 9 10)) ; adunarea a două liste

(map (curry+ 1) '(1 2 3 4 5)) ; incrementarea unei liste, cu funcție curry
(map apply (map curry+ '(1 2 3 4 5)) (map list '(6 7 8 9 10))) ; adunarea a două liste, în două faze


(filter odd? '(1 2 3 4 5))

(foldl + 0 '(1 2 3 4 5))

; verific dacă o listă de numere e sortată
(define (check-sort L)
  (if (eq? #f (foldl
               (λ (x res)
                 (if (eq? res #f)
                     #f ; am descoperit înainte că lista nu e sortată
                     (if (<= res x)
                         x ; până acum e sortată
                         #f ; am descoperit acum că lista nu e sortată
                         )))
               (car L) L))
      #f #t ; returnez explicit #t sau #f
      ))
(check-sort '(1 2 3 4 5 6))
(check-sort '(1 2 1 3 4 5 6))

; variantă mai scurtă, folosesc operatori logici
(define (check-sort2 L)
  (and (foldl (λ (x res) (and res (<= res x) x)) (car L) L) #t))
(check-sort2 '(1 2 3 4 5 6))
(check-sort2 '(1 2 1 3 4 5 6))

; map, implementat cu fold
(define (my-map f L)
  (foldr (λ (elem Lpart) (cons (f elem) Lpart)) '() L))
(my-map (curry+ 1) '(1 2 3 4 5))

; filter, implementat cu fold
(define (my-filter f L)
  (foldr (λ (elem Lpart) (if (f elem) (cons elem Lpart) Lpart)) '() L))
(my-filter odd? '(1 2 3 4 5))