#lang racket


; pentru ce folosim de obicei prelucrări iterative pe o colecție?
; afișăm
; modificăm elementele
; selectăm elemente
; maxim
; sortare


; afișăm
(map display '(a b c d))

; "modificăm" elementele
(map (λ (x) (* x x)) '(1 2 3 4))

(map + '(1 2 3 4) '(5 6 7 8) '(9 10 11 12))


; selectare anumite elemente din listă
(filter even? '(1 2 3 4 5 6 7 8))

; paranteză member / if
;(member 'c '(a b c d e)) -> '(c d e)
;(member 'c '(a b c d c e)) -> '(c d c e)
;(if (member 'c '(a b c d c e)) 'da 'nu) -> 'da
;(if 0 'da 'nu) -> 'da



; intersecție
(filter (λ (e) (member e '(a e i o u))) '(a b c d e f g h i))

; diferență
(filter (λ (e) (not (member e '(a e i o u)))) '(a b c d e f g h i))

; maxim
(foldl (λ (e max)
         (if (> e max)
             e
             max))
       0
       '(6 3 7 2 1 9 34 2 6)
       )


(define (map-with-fold f L)
  (foldr (λ (e rez)
           (cons (f e) rez)
           )
         '()
         L))
(map-with-fold add1 '(1 2 3 4))

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

(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))

; sortăm
(define (ins new sorted) ; întoarcem o listă cu new inserat la poziția corectă în sorted
  (if (null? sorted) (list new) ; dacă sorted e vid
      (let ((newsorted ; rezultatul pentru când new trebuie inserat în altă parte decât la sfârșit
             (foldl (λ (e rez)
                      (cond
                        ((< e new) (cons e rez)) ; nu este încă momentul să inserăm pe new
                        ((member new rez) (cons e rez)) ; am inserat deja pe new
                        (else (cons e (cons new rez))) ; acum este momentul să inserăm pe new
                        ))
                    '()
                    sorted
                    )))
        (reverse (if (member new newsorted) newsorted
                     ; new trebuia inserat la sfârșit:
                     (cons new newsorted))))))

(define (ins-sort L)
  (foldl ins '() L))
(ins-sort '(5 3 9 2 8 6 3 6))


; map-filter-with-fold

(define L '(1 2 3))
(+ (car L) (cadr L) (caddr L))
(+ (first L) (second L) (third L))

(apply + '(1 2 3)) ; aplică + pe 3 argumente, o singură dată
(foldl + 0 '(1 2 3)) ; aplică + pe câte 2 argumente, de 3 ori

(define M '((1 2 3) (4 5 6) (7 8 9) (10 11 12)))

;(map + (car M) (cadr M)...
(apply map + M)

(display '================curry/uncurry)(newline)
; curry / uncurry

; curry transformă o funcție de 2 args în formă uncurry în funcție în formă curry
(define (curry2 f) ; f are 2 args
  ; 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))))

((curry2 +) 5) ; 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 +
(((curry2 +) 5) 6)


(map ((curry2 cons) 'a) '(1 2 3 4))
; map primește pe cons, aplicat deja parțial pe argumentul 'a
; echivalent cu:
(map (λ (e) (cons 'a e)) '(1 2 3))

(apply ((curry map) +) M)

; Haskell: map (+1) [1..5]

(filter
 ((curry2 member) 1) ; funcție care așteaptă o listă ca să verifice dacă 5 este membru în ea
 '((1 5 6)
   (2 8 9 1)
   (3 4 5)
   (54 1 2)
   ))

;(map (λ (lista) (filter (λ (e) (not (null? e))) lista))
(map ((curry2 filter) (compose not null?))
     '((1 2 () 4 ())
       (1 2 3 4)
       (() () ())
       (1 2 ())))


; există elemente pare într-o listă?
(not (null? (filter even? '(1 3 5 9 8 7))))

; toate elementele dintr-o listă sunt pare?
(null? (filter (compose not even?) '(2 4 8 6 10)))

(andmap identity '(1 #t 0 ()))
; apply and

; există elemente pare într-o listă?
(ormap even? '(1 3 5 9 8 7))

; toate elementele dintr-o listă sunt pare?
(andmap even? '(2 4 8 6 10))