#lang racket

; transpusa
(define M '((1 2 3)
            (a b c)
            (5 6 7)
            (x y z)))
; 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))
(p M "matricea inițială")

; fiecare linie a transpusei este o listă din elemente de pe același index
; de pe liniile lui M
(p (map list (car M) (cadr M) (caddr M) (cadddr M))
    "map simplu")
; dar asta funcționează doar când știu câte rânduri va avea matricea M

; folosesc apply, dar aici nu mă ajută încă
(p (apply map
          (list list (car M) (cadr M) (caddr M) (cadddr M)))
   "apply 1:")

; lista de argumente pentru map este
; funcția list urmată de fiecare dintre rândurile lui M
(cons list 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 pentru map:
    (cons
     list ; primul argument pentru map este funcția list
     M) ; restul argumentelor sunt chiar rândurile matricei M
    ) "apply 2:")

; sau, folosesc forma de apply cu mai mult de 2 argumente
; funcția list este argument "fix", care este dat lui apply exact așa
; M este lista celorlalte argumente pentru map (rândurile matricei)
(p (apply map list M) "apply 3:")

; transpose folosind fold. Considerăm că matricea M are m linii și n coloane
(define (transpose M)
  (foldl
   (λ (row Tp)
     ; 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 rowTp)
            ; adăugăm un element din rândul i (row) la sfârșitul liniei corespunzătoare din transpusă
            (append rowTp (list eRow)))

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

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

(p (map (λ (e) '()) (car M)) "valoarea inițială")
(p (transpose (take M 1)) "transpose 1 rând")
(p (transpose (take M 2)) "transpose 1 rând")
(p (transpose M) "transpose M")

(display '---)(newline)
; legare

; define
(define x 5)

; legare cu lambda
((lambda (a b) (+ a b))
 1 2)  ; la aplicare a <- 1, b <- 2


(define evens (λ (L)
                (cond
                  [(null? L) null]
                  [(even? (car L)) (cons (car L) (evens (cdr L)))]
                  [else (evens (cdr L))]
                  )))
(evens '(1 2 3 4 5 6 7 8))

; exemplu legare folosind lambda:
; punem o parte din cod într-o funcție anonimă, pentru a putea 'salva' valorile
;  întoarse de (car L) și de (evens (cdr L)), pe care le pasăm ca parametru funcției
;  anonime
(define evens2 (λ (L)
                 (if (null? L) null
                     ((lambda (primul-element
                               rezultat-rest)
                        (cond 
                          [(even? primul-element)
                           (cons primul-element rezultat-rest)]
                          [else rezultat-rest]
                          ))
                      (car L)
                      (evens2 (cdr L))
                      ))))
(evens2 '(1 2 3 4 5 6 7 8))

; aceeași legare, dar folosind let
(define evens3 (λ (L)
                 (if (null? L) null
                     (let (
                           [primul-element (car L)]
                           [rezultat-rest (evens3 (cdr L))]
                           )
                       (cond 
                         [(even? primul-element)
                          (cons primul-element rezultat-rest)]
                         [else rezultat-rest]
                         ))
                     )))
(evens3 '(1 2 3 4 5 6 7 8))


(define (evens4a L)
  (if (null? L) null
      (let (
            [primul-element (car L)]
            [restul-listei (cdr L)]
            )
        (let ([rezultat-rest (evens4a restul-listei)])
          (cond 
            [(even? primul-element)
             (cons primul-element rezultat-rest)]
            [else rezultat-rest]
            )))
      ))
(evens4a '(1 2 3 4 5 6 7 8))


(let ((a 1)
      (b 2))
  (let ((a 3)
        (c a)) ; a din primul let
    (+ a c))) ; a din al doilea let


(define evens4 (λ (L)
                 (if (null? L) null
                     (let* (
                            [primul-element (car L)]
                            [restul-listei (cdr L)]
                            [rezultat-rest (evens4 restul-listei)]
                            )
                       (cond 
                         [(even? primul-element)
                          (cons primul-element rezultat-rest)]
                         [else rezultat-rest]
                         ))
                     )))
(evens4 '(1 2 3 4 5 6 7 8))



(letrec ([evensR (λ (L)
                   (cond
                     [(null? L) null]
                     [(even? (car L)) (cons (car L) (evensR (cdr L)))]
                     [else (evensR (cdr L))]
                     ))])
  (evensR '(1 2 3 4 5 6 7 8)))

; evensR ; aici nu este vizibil


; named let ; definesc o funcție recursivă și să o apelez o dată
(let evensR ([L '(1 2 3 4 5 6 7 8)])
  (cond
    [(null? L) null]
    [(even? (car L)) (cons (car L) (evensR (cdr L)))]
    [else (evensR (cdr L))]
    )
  )

(display '---)(newline)
(split-at '(1 2 3 4 5 6 7 8) 4)

(display '---)(newline)
(values 1 2 3)

(let-values ([(prima-parte a-doua-parte)
              (split-at '(1 2 3 4 5 6 7 8) 4)])
  (display prima-parte)(newline)
  (display a-doua-parte))