#lang racket/gui
(require racket/trace)

; exemple prelucrări iterative:
; afișare elemente
; căutare element
; filtrare elemente cu o proprietate
; acumulare peste elementele dintr-o listă / range
; aplicare efect lateral de mai multe ori



; prelucrări pe o colecție

; efectuare prelucrare pe fiecare element
;(map f L)
(map add1 '(1 2 3 4))
(map display '(a b c d))
(map (λ (e) (display e) (newline)) '(a b c d))

(define (zip f L1 L2)
  (map f L1 L2))
(zip cons '(1 2 3 4) '(a b c d))


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



; filtrare elemente cu o anumită proprietate

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

(define (intersect L1 L2)
  (filter (λ (e) (member e L1)) L2))
(intersect '(1 2 3 4 5 6) '(6 9 2 14 3))


; agregare elemente într-o valoare


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

; verifică dacă o listă este sortată crescător
(define (check-sort L)
  (if (null? L) #t ; o listă vidă este sortată
      ; 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
      (foldl (λ (current previous)
               (if previous ; previous are valoarea #f sau elementul anterior vizitat
                   (if (<= previous current)
                       current ; lista este sortată, întorc elementul curent ca viitor element anterior
                       #f ; lista nu este sortată
                       )
                   #f ; dacă am găsit anterior că nu e sortată, continuă să nu fie sortată
                   ))
             (car L) ; primul element cu care să compar
             (cdr L) ; încep verificarea cu al doilea element
             )))

(display "----")(newline)
(check-sort '(1 2 3 4 5))
(check-sort '(1 2 4 3 5))
(check-sort '())
(check-sort '(1))


(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 (λ (current previous)
                (and previous
                     (and (<= previous current)
                          current)
                     ))
              (car L)
              (cdr L)) #t)))

(display "--")(newline)
(check-sort-2 '(1 2 3 4 5))
(check-sort-2 '(1 2 4 3 5))
(check-sort-2 '())
(check-sort-2 '(1))


(define L1 '(1 2 3))

(+ (car L1) (cadr L1) (caddr L1))
(apply + L1)
(apply + 10 20 30 40 L1)


(display '===============_exemple_fold)(newline)


(define (map-with-fold f L)
  (foldr (λ (e acc)
           (cons (f e) acc)
           )
         '() L))

(map-with-fold (λ (e) (* e e)) '(1 2 3 4 5))

(define (filter-with-fold f L)
  (foldr (λ (e acc)
           (if (f e) (cons e acc) acc))
         '() L))
(filter-with-fold odd? '(1 2 3 4 5))

(define (map-filter-with-fold fMap fFilter L)
  (foldr (λ (e acc)
           (if (fFilter e)
               (cons (fMap e) acc) acc))
         '() L))
(map-filter-with-fold (λ (e) (* e e)) odd? '(1 2 3 4 5))


; funcții curry / uncurry
(display '===============_curry-uncurry)(newline)

; curry transformă o funcție de 2 args în formă uncurry în funcție în formă curry
(define (curry f)
  ; alternativ: (define curry (λ (f)
  ; dacă curry primește un parametru f, atunci întoarce o funcție de arg1...
  (λ (arg1)
    ; ...care când primește un argument, întoarce o funcție de arg2...
    (λ (arg2)
      ; ... care când primește un argument, aplică pe f pe arg1 și arg2
      (f arg1 arg2))))

((curry +) 1) ; funcția +, transformată în formă curry, aplicată _parțial_ pe un argument
; rămâne să mai primească un argument pentru a se aplica de fapt funcția +
(((curry +) 1) 2)


(map ((curry cons) 'a) '(1 2 3 4))
; map primește pe cons, aplicat deja parțial pe argumentul 'a

; verific în care dintre liste se găsește elementul 5
(filter ((curry member) 5) ; funcție care așteaptă o listă ca să verifice dacă 5 este membru în ea
        '((1 3 5)
          (2 4 6)
          (5 6 7)
          (8 9 10)))

; transformare în formă curry + inversare argumente
(define (flipCurry f)
  (λ (arg2)
    (λ (arg1)
      (f arg1 arg2))))

; verific care dintre elementele (1 2 3 4 5) sunt în lista mare
(filter
 ((flipCurry member)
  '(1 3 5 7 9 11 13 15 17 19)) ; filter primește o funcție care verifică dacă argumentul este parte din lista '(1 3 5 ...)
 '(1 2 3 4 5))


(display '===============_any-all)(newline)

; există elemente impare?
; "any"
(not (null? (filter odd? '(2 4 6 5 8 10))))
(not (null? (filter odd? '(2 4 6 8 10))))

; "all"
(null?
 (filter (λ (e) (not (even? e))) '(2 4 6 8 10)))

(null?
 (filter (compose not even?) '(2 4 6 8 10)))


(display '===============_trace)(newline)

(define (map-with-fold2 f L)
  (define ffold (λ (e acc)
                  (cons (f e) acc)
                  ))
  (trace ffold)
  (foldr ffold
         '() L))

(map-with-fold2 (λ (e) (* e e)) '(1 2 3 4 5))


(define (sumList L)
  (if (null? L) 0
      (+ (car L) (sumList (cdr L)))))
(trace sumList)
(sumList '(1 2 3 4 5))

(define (sumListT L res)
  (if (null? L) res
      (sumListT (cdr L) (+ (car L) res))))
(trace sumListT)
(sumListT '(1 2 3 4 5) 0)