#lang racket



(define M '((1 2 3) (a b c) (x y z)))

(define (d-m M) (map (λ (R) (display R) (newline)) M) (display ""))


(display '::::::::::::::::::::::::::::::::::TRANSPOSE)(newline)

(define (transpose-1 M)
  (foldr (λ (R T) ; rând, transpusa
           (map cons R T)
           ;(λ (e RT) ; RT din T, e din R
           ;     (cons e RT))
           )
         (map (λ (c) '()) (car M))
         M))

(d-m (transpose-1 M))

(display '::::::::::::::::::::::::::::::::::CURRY-UNCURRY)(newline)

; named let
; (let nume ( (nume-par-1 par-actual-1-1a-prima-aplicare) (nume-par-2 par-actual-2-1a-prima-aplicare ) )
;        corp (pot recursiv nume))
; --> are ca efect: (nume par-actual-1-1a-prima-aplicare par-actual-2-1a-prima-aplicare)

; curry->uncurry
; ne dorim ca ((my-uncurry fc) a1 a2 a3 a3) să rezulte în ((((fc a1) a2) a3) a4)
(define 2uncurry
  (λ (f-curry) ; f curry
    (λ args  ; în args este întreaga listă de argumente
      ; întoarcem o funcție uncurry, args sunt argumentele pentru f
      (foldl (λ (arg fp) ; fp - rezultat aplicare parțială f
               (fp arg))
             ; astfel: la fiecare argument, luăm funcția întoarsă de apelul (curry) precedent, și îi mai dăm un argument;
             ; dacă argumentul nu a fost ultimul, λ din foldl întoarce o nouă funcție, aplicată parțial pe argumentele de până acum;
             ; dacă argumentul a fost ultimul, λ din foldl va întoarce rezultatul aplicării funcției curry pe toate argumentele date.
             f-curry args)
      )))

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

; transformăm curry în funcție uncurry și o aplicăm ca atare
((2uncurry curry+3) 1 2 3) ; --> 6


; uncurry->curry pentru o funcție f, unde f ia nArg argumente.
; ne dorim ca în loc să aplicăm f ca (f a1 a2 a3 a4) să aplicăm astfel (((((curry f) a1) a2) a3) a4)
(define (2curry f-uncurry nArg)
  (let curry-rec ((list-arg '()))
    (if (equal? (length list-arg) nArg) ; au fost date toate argumentele
        (apply f-uncurry (reverse list-arg)) ; => aplicăm funcția (lista de argumente a fost construită cu cons și este inversată
        (λ (x) (curry-rec (cons x list-arg))) ; altfel, întoarcem o nouă funcție,
        ; care la evaluare apelează din nou curry-rec, cu o listă de argumente îmbogățită
        )))

((((2curry + 3) 1) 2) 3)