#lang racket

; (paranteză cons:
;> (cons '(1 2 3 4) 'x)
;'((1 2 3 4) . x)
;> (cons 'x '(1 2 3 4))
;'(x 1 2 3 4)
;> '(x . (1 2 3 4))
;'(x 1 2 3 4)
;>
;)

; (paranteză if / orice condiții în Racket:
;   în Racket se consideră "adevărată" orice valoare
;       care nu este #f
;   (if 0 'a 'b) -> 'a
;   (if '() 'a 'b) -> 'a
;   (if null 'a 'b) -> 'a
; )

; curry [Haskell Curry]

; o funcție curry are un singur argument
; alternativ: o funcție curry își primește argumentele pe rând
; o funcție uncurry își primește toate argumentele o dată

; λ = lambda

(define curry+2
  (λ (x)
    (λ (y)
      (+ x y)
      )))

; (curry+2 2) ~ (f (x) (+ x 2)) ~
;    (compose add1 add1) ~ (+ 2)

; apel curry:
;> curry+2
;#<procedure:curry+2>
;> (curry+2 2)
;#<procedure:...ket-functionale.rkt:12:4>
;> ((curry+2 2) 3)
;5

((curry+2 2) 3)

; (curry+2 2) -> închidere funcțională
;     { (λ (y) (+ x y)) ; <x: 2>}
;     (λ (y) (+ 2 y))

(define curry+3
  (λ (x)
    (λ (y)
      (λ (z) 
        (+ x y z)
        ))))

;---------------------------------------------

; funcționale - funcții care iau alte funcții ca argumente

; map realizează o aceași prelucrare pe fiecare dintre
; elementele unei liste, în mod **independent**.


(display "-------------- map \n")

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


(map (λ (x) (* 2 (sqrt x))) '(1 4 16 144 64))
; același lucru cu:
(map (compose ((curry *) 2) sqrt) '(1 4 16 144 64))

(map cons '(1 2 3 4) '(a b c d))
(map list '(1 2 3 4) '(a b c d) '(#t #f x y))
(map list '((1 1 1) 2 3 4) '(a b c d) '(#t #f x y))

; compose:   (f . g)(x) = f(g(x))


(display "-------------- filter \n")

(filter odd? '(1 2 3 4 5 6 7))
(define (lesser L n) (filter (λ (x) (< x n)) L))
; la fel cu
(define (lesser2 L n) (filter ((curry >) n) L))
(lesser '(7 3 7 21 9 3 1) 7)


(display "-------------- apply \n")

(apply + '(1 2 3 4))
(define (sumList L) (apply + L))

(map (apply compose (list
                     (λ (x) (>= x 8))
                     ((curry *) 2)
                     sqrt))
     '(1 16 4 144 64))


(display "-------------- test \n")

; Test: Implementați ca funcție recursivă
; numele de familie care începe cu o literă < M:   map
; numele de familie care începe cu o literă >=M:   filter

(define (myMap f L)
  (if (null? L)
      null
      (cons (f (car L)) (myMap f (cdr L)))
      ))
(myMap odd? '(1 2 3 4 5 6 7))

(define (myFilter f L)
  (if (null? L) null
      (if (f (car L)) (cons (car L) (myFilter f (cdr L)))
          (myFilter f (cdr L))
          )))
(myFilter odd? '(1 2 3 4 5 6 7))

(display "-------------- fold \n")

(foldl cons 0 '(1 2 3 4))

(foldr cons 0 '(1 2 3 4))


(define (mapW/Fold f L)
  (foldl (λ (e rez)
           ; în rez am rezultat map pentru prima parte a listei
           (cons (f e) rez)
           )
         '() L))
(mapW/Fold odd? '(1 2 3 4 5 6 7))

(define (remDupsLeft L) ; păstrează prima apariție
  (reverse (foldl (λ (e rez)
                    (if (member e rez)
                        rez
                        (cons e rez)
                        ))
                  '()  L)))

; '(1 2 3 4 3 5 2 6 3 1)
;  rez-> '(4 3 2 1)

(remDupsLeft '(1 2 3 4 3 5 2 6 3 1))