#lang racket


; funcții curry / uncurry

; apel uncurry
(+ 2 3) ; aplicare uncurry

(define curry+
  (λ (x) ; + ca funcție curry, este funcție de 1 argument (primul operand)
    (λ (y) ; întoarce altă funcție, care așteaptă al doilea operand
      (+ x y))))  ; pentru a întoarce rezultatul

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

; adunarea ca funcție curry de 3 argumente
(define curry+3 (λ (x) (λ (y) (λ (z) (+ x y z)))))


; funcționale

; filter

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

(filter (λ (x) (> (* x x) 5)) '(1 2 3 4 5))

; map

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

(map (λ (x) (* x x)) '(1 2 3 4 5))

(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) '(20 30 40 50 60)) ; adunarea a mai multe liste

(map (curry+ 1) '(1 2 3 4 5)) ; incrementarea unei liste, cu funcție curry
(map list '(a b c d e) '(1 2 3 4 5) '(#t (2 . 3) x y z))
; -> '((a 1 #t) (b 2 (2 . 3)) (c 3 x) (d 4 y) (e 5 z))


; apply

(apply + '(1 2 3 4 5))
; suma listei L:
(let ((L '(1 2 3))) (+ (car L) (cadr L) (caddr L))) ; știu că lista are 3 elemente
(let ((L '(1 2 3))) (apply + L)) ; nu e nevoie să știu lungimea listei L
                                 ; dar știu că + are număr variabil de argumente


; foldl / foldr

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


; utilizare fold:

; verific daă o listă este sortată crescător
(define (check-sort L)
  (if (null? L) #t
      ; folosesc fold:
      ; funcția din fold va întoarce #f dacă lista nu e sortată
      ; sau va întoarce ultimul element vizitat, pentru a verifica dacă este mai mic
      ;   decât elementul curent
      (if (foldl (λ (e res) ; res are valoarea #f sau elementul anterior vizitat
                   (if (equal? res #f)
                       #f
                       (if (>= e res)
                           e ; lista este sortată, întorc elementul curent
                           #f ; lista nu este sortată
                           )))
                 (car L) (cdr L)) ; pornesc cu primul element (ordonat corect) și continui cu restul
          #t #f))) ; dacă fold întoarce diferit de #f (un element), atunci explicit #t; altfel #f

; mai elegant
(define (check-sort-2 L)
  (or (null? L)
      (and ; dacă fold întoarce diferit de #f, atunci #t (ultimul argument al lui and); altfel #f
       (foldl (λ (e res) ; res are valoarea #f sau elementul anterior vizitat
                (and res (and (>= e res) e)))
              (car L) (cdr L))
       #t)))

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

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

; suma elementelor impare dintr-o listă
(define (sumodd L)
  (foldl
   (λ (e rez) ; în rez rezultatul elementelor de la primul până înainte de e
     (if (odd? e) (+ e rez) rez))
   0 L))