#lang racket

; ((1 2 3) (4 5 6) (7 8 9))
; (6  15  24)

(define (uncurry->curry f)
  (λ (x)
    (λ (y)
      (f x y))))

(define (overlay-> initial values)
  (foldl + initial values))

(define (slim-horizontal M)
  ;(map overlay-> M)
  ; dar overlay are 2 argumente
  ;(map (λ (linie) (overlay-> 0 linie)) M)
  ; sau transform, overlay în funcție curry, o aplic parțial pe 0
  ; (uncurry->curry overlay->)   este o funcție în formă curry
  ; ((uncurry->curry overlay->) 0)   este o aplicare parțială a unei funcții curry de 2 args,
  ; îmi întoarce o funcție curry care mai așteaptă încă un argument
  (map  ((uncurry->curry overlay->) 0)  M)
  )

(define matrix '((1 2 3) (4 5 6) (7 8 9)))

(slim-horizontal matrix)


; am ((1 2 3) (4 5 6) (7 8 9))
; obțin ((1 4 7) (2 5 8) (3 6 9))



; funcțională care să îmi ia elementele de la aceeași poziție din mai multe liste
(map  list  '(1 2 3) '(4 5 6) '(7 8 9))

; vreau să aplic o funcție pe un număr de argumente pe care nu îl cunosc apriori
; (apply  <aici funcția pe care vreau să o aplic pe un număr necunoscut de argumente>
;   <lista de argumente>)
; deci (apply map <argumentele pentru map, într-o listă>)
(apply map  (list list  '(1 2 3) '(4 5 6) '(7 8 9)))
;      construiesc o listă în care primul element este funcția list, iar restul elementelor sunt niște liste
(apply map  (cons list matrix))

(define (transpose M)
  (apply map (cons list matrix))
  )

; (apply f a1 a2 ...  am L) unde L=[e1, e2, ... en]
; -> (f a1 a2 ... am e1 e2 ... en)
(apply map                   list            matrix)
;  funcția de aplicat   arg "fix" a1     lista cu celelalte argumente de dat lui map



;> (take '(1 2 3 4 5 6) 2)
;'(1 2)
;> (drop '(1 2 3 4 5 6) 2)
;'(3 4 5 6)

(define (takeW/Fold L n)
  (reverse (foldl (λ (e taken)
                    (if (< (length taken) n)
                        (cons e taken)
                        taken)
                    )
                  '() L)))

; Legare

(define test (λ (x y) ; linia 1
               (λ (x y) ; linia 2
                 (λ (z) ; linia 3
                   (+ x y z) ; aici sunt x și y de pe "linia 2"
                   ))))


; test este legat la o valoare care este o funcție de 2 argumente
; când teste este aplicat pe 2 valori A și B, x și y din "linia 1" sunt legate la cele 2 valori A și B
; evaluarea aplicării lui test va întoarce o valoare de tip funcție de 2 argumente "fxy"
; la aplicarea lui "fxy" pe 2 valori C și D, x și y din "linia 2" (nu au nicio legătură cu x și y din "linai 1"
; vor fi legate la aceste valorile C și D, iar apelul lui "fxy" va întoarce o valoarea de tip funcție "fx"
; la aplicarea valorii "fx" pe o valoare E, variabila z din "linia 3" va fi legată la E
; și se va întoarce suma C+D+E

(define a 5)

(define f1 (lambda (x)
             (+ x a)))
; la evaluarea lui define, f1 este legat la o închidere funcțională
; {(lambda (x) (+ x a)); <a <- 5>}
; conține legarea pentru a care era vizibilă la momentul construcției funcției

(define f2 (lambda (a)
             (cons a (f1 2))))


; perfect echivalente:
; (define f (lambda (x y z) corp))
; cu
; (define (f x y z) corp)

; (let lista-definiții  corp)
; lista-definiții = ( (nume val) (nume val) ....)

(let (; lista de definiții
      (a 1)
      (b 2)
      (c 3)
      )
  ; corp - calculează valoarea întoarsă de let
  ; în corp văd toate numele definite în lista de definiții, cu valorile respective la care au fost legate
  (list a b c)
  )

(let ((a 1) (b 2))
  (display a) (newline) ; aici văd a = 1
  (let ((a 5) (b 6)) ; aici se contruiesc ALTE 2 variabile cu numele a și b
    (cons a b) ; aici văd a și  b din letul cel ami apropiat
    ))

; în let numele definite sunt vizibile numai în corpul let-ului

(define List '(1 2 3 4 5 6))
(let* ((A (take List 3))
       (B (drop List 3))
       (Last (last A))
       (P (list (foldl + 0 B) (cons Last (car B))))
       )
  P ; corpul lui let*
  )

; în let* numele definite sunt vizibile în corpul let-ului, și în definițiile următoare din același let*


(letrec ((myeven? (λ (x) (if (zero? x) #t (myodd? (sub1 x)))))
         (myodd? (λ (x) (if (zero? x) #f (myeven? (sub1 x)))))
         )
  (myeven? 6)
  )

; în letrec pot vedea într-o definiție toate numele definite în letrec
; în letrec sunt vizibile peste tot toate numele definite în acel letrec


; temă: let-values

(display '--------)(newline)
(define (f a b c d) (values (cons a b) (cons c d)))
(f 1 2 3 4)
(display '--------)(newline)


; named let
(let fact5 ((n 5))
  (if (zero? n) 1 (* n (fact5 (sub1 n)))))
; am definit funcția fact5 (vizibilă doar în corpul let-ului) cu param formal n
; și am apelat-o pe valoarea 5

;(let f ((p1 v1) (p2 v2))
;  corp)
; named let construiește o funcție cu nume (poate fi recursivă)
; și care are parametrii formali p1 p2 și corpul corp
; și apelează funcția pe valorile v1 v2

; folosesc named let pentru a construi și apela o funcție recursivă de care am nevoie o singură dată