#lang racket

; pentru ce folosim de obicei prelucrări iterative pe o colecție?

; modificăm date
; selectăm elemente
; iterăm
; obținem un rezultat peste întreaga colecție (sumă, maxim)
; verificare prezență sau absența unui element
; afișare


(define L '(1 2 3 4 5 6 7))

(map add1 L) ; prelucrare iterativă
(map display L)
(filter odd? L) ; selecție
(foldl + 0 L) ; sumă
(foldl max (car L) (cdr L)) ; maxim

; map cu mai mult argumente
(map + '(1 2 3 4) '(5 6 7 8) '(1 2 3 4))


; construiește o listă cu rezultatul
; lui f-proc pentru fiecare element
; din L pentru care f-sel este adevărat
(define (map-filter f-proc f-sel L)
  (foldr (λ (e acc)
           (if (f-sel e)
               (cons (f-proc e) acc)
               acc
               )
   ) '() L))

(map-filter sqr odd? L)


(define (sort L)
  (foldl (λ (e sorted) ; fiecare element e în inserez la poziția corectă în lista restului elementelor, deja sortate
           (append
            (filter (λ (x) (<= x e)) sorted)
            (list e)
            (filter (λ (x) (> x e)) sorted)
            )
           ) '() L))
(sort '(6 2 7 8 32 6 2 1 5 3 7 2 6))


(apply + L) ; aplicare funcție pe un număr oarecare de argumente, care provin dintr-o listă

(define M '((1 2 3 4)
            (a b c d)
            (5 6 7 8)))

(apply map list M)
  ; (map list row1(M) row2(M) ...)


; if funcție nestrictă
(if #t 5 (/ 5 0)) ; ramura de false nu se evaluează
;(if #f 5 (/ 5 0)) ; eroare pentru că ramura de false se evaluează
;(+ 5 (/ 5 0)) ; pentru funcțiile stricte, se evaluează toți parametri


; funcții curry
(define curry-member ; member în formă curry
   (λ (e) ; primirea fiecărui argument rezultă în întoarcerea unei alte funcții
     (λ (L) ; iar la primirea ultimului argument calculez valoarea funcției
       (if (member e L) #t #f))))
(define curry-+
  (λ (a)
    (λ (b)
      (+ a b))))

(map (λ (x) (+ x 5)) L) ; funcție anonimă
(map (curry-+ 5) L) ; aplicare parțială a lui +
; map (+1) l ; în Haskell

; ia o funcție curry și întoarce o altă funcție curry cu aceeași funcționalitate,
;  dar care primește argumentele în ordine inversă
(define (flip f)
  (λ (a) (λ (b) ((f b) a))))

; ce elemente din lista dată fac parte din lista '(1 2 3 4) -- primesc pentru fiecare #t sau #f
(map ((flip curry-member) '(1 2 3 4))
     '(6 4 8 2 5 10))

; filter pentru intersecție
(filter ((flip curry-member) '(1 2 3 4)) '(6 4 8 2 5 10))

; ((curry +) 5) -- funcție de 1 arg care își adună argumentul cu 5
(map ((curry +) 5) L)

; reluăm sort, folosim aplicare parțială a operatorilor de inegalitate, transformați în formă curry
(define (sort2 L)
  (foldl (λ (e sorted)
           (append
            (filter ((curry >=) e) sorted)
            (list e)
            (filter ((curry <) e) sorted)
            )
           ) '() L))
(sort2 '(6 2 7 8 32 6 2 1 5 3 7 2 6))

(map (λ (x) (cons 'pre x)) '(a b c d))
(map ((curry cons) 'pre) '(a b c d))
(map ((flip (curry cons)) 'post) '(a b c d))