#lang racket


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

; afișează o matrice
(define (p M . msg)
  (if (not (null? msg)) (and (display (car msg)) (newline)) (newline))
  (andmap (λ (row)
            (and (display row) (newline)))
          M))

; aș vrea să fac ceva de genul
; (map list (first M) (second M) (third M) (fourth M))
; dar asta funcționează doar când știu câte rânduri va avea matricea M

(p (apply ; apply apelează funcția map pe n+1 argumente, unde M are n rânduri
    map ; map va primi rândurile matricei M, ca liste diferite
    ; construiesc lista de argumente pentur map:
    (cons
     list ; primul argument pentru map este funcția list
     M) ; restul argumentelor sunt chiar rândurile matricei M
    ) "apply 1:")
(newline)

; sau, folosesc forma de apply cu mai mult de 2 argumente
(p (apply map list M) "apply 2:")



; transpose folosind fold. Considerăm că matricea M are m linii și n coloane
(define (transpose1 M)
  (foldl
   (λ (row T)
     ; lambda primește un rând i din M și transpusa T a rândurilor 1..i-1

     ; folosim map cu două liste pentru a adăuga câte un element din rândul i la
     ; liniile transpusei
     (map (λ (erow rowT)
            ; adăugăm un element din rândul i (row) la sfârșitul liniei corespunzătoare din transpusă
            (append rowT (list erow)))

          ; iterăm simultan peste rândul i și peste rândurile matricei T
          row T)
     )

   ; pentru valoarea inițială a transpusei, construiesc o matrice cu m rânduri goale
   (map (λ (e) '()) (car M))

   ; iterăm peste matricea M, practic peste lista de rânduri
   M
   ))
(newline)
(p (transpose1 M) "transpose 1:")

; la fel ca mai sus, dar mai elegant
; folosim cons și foldr în loc de append și foldl
(define (transpose2 M)
  (foldr
   ;   (λ (row T) (map cons row T))
   ; aplicăm map parțial pe cons, rămân de primit rândul și transpusa
   ((curry map) cons)
   (map (λ (e) '()) (car M))
   M
   ))
(newline)
(p (transpose2 M) "transpose 2:")


(display '===================_legare)(newline)

(let [(a 1)
       (b 2)
       ;       (c (+ a b)) ; a și b nu sunt vizibile în expresia pentru c
       ;       (d (/ a c)) ; a și c nu sunt vizibile în expresia pentru d
       ]
  (/ a (+ a b)))

(let* [(a 1)
       (b 2)
       (c (+ a b))
       (d (/ a c))
       ]
  d)

(letrec [(myeven? (λ (n) (if (zero? n) #t (myodd? (sub1 n)))))
         (myodd?  (λ (n) (if (zero? n) #f (myeven? (sub1 n)))))]
  (myodd? 5))


(define (f n) (modulo n a))

(define a 2)
(f 5)

;(define a 3) ; dacă selectăm limbajul Pretty Big și comentăm #lang racket, putem avea definire multiplă
;(f 5)

; definire cu funcție recursivă
;(define fact (λ (n)
;               (if (zero? n) 1
;                   (* n (fact (sub1 n))))))
;(fact 5)

; definire folosind letrec
(letrec ((fact (λ (n)
                 (if (zero? n) 1
                     (* n (fact (sub1 n)))))))
  (fact 5))
;(fact 4) ; nu mai e vizibil

; named let
(let fact ((n 5))
  (if (zero? n) 1
      (* n (fact (sub1 n)))))

; sau, tail-recursive
(let factT ((n 5) (rez 1))
  (if (zero? n) rez
      (factT (sub1 n) (* n rez))))


; întoarcere a mai multor valori dintr-o funcție
(define fvals (λ (a b c)
                (values a b c)))
(fvals 1 2 3)


(let-values ( ((a b c) (fvals 1 2 3)) )
  (+ a b c))