#lang racket

; ------------------Expresii------------------
; expresie = (f e1 e2 .. en)
;(+ 6 (- (* 5 2) 3) 1)


; ------------------Define------------------
; (define identificator expresie)

;(define PI 3.14159265)
;(define r 5)
;(define area (* PI r r))


; ------------------Funcții------------------
; funcții anonime: (lambda listă-parametri corp)

; Ex: λx.x - în Calcul Lambda
;(λ (x) x)
;((λ (x) x) 2) - observă parantezele pentru aplicație

; Ex: λx.λy.(x y) - în Calcul Lambda
; de definit și de aplicat pe valori "cu sens"
;(((λ (x)
;    (λ (y)
;      (x y)))
;  add1)
; 5)
;
;Descompus pe pași:
;(define f (λ (x)
;            (λ (y)
;              (x y))))
;(define g (f add1))
;->
;(λ (y)
;  (add1 y))

;(g 5)


(define arithmetic-m
  (λ (x y)
    (/ (+ x y) 2)))
;(arithmetic-m 6 12)

; (define (f x y ... ) corp)
(define (arithmetic-mean x y)
  (/ (+ x y) 2))

(define (sum-of-squares x y)
  (+ (sqr x) (sqr y)))
;(sum-of-squares (+ 1 2) (* 3 5))


; ------------------Perechi------------------
; constructor: cons
; selectori: car, cdr
;(cons (cons 1 2) 'a)
;(cons + 3)
;((car (cons + 3)) 4 6)
;(car (cons (cons 1 2) 5))
;(cdr '(4 . b))

; Ex: Folosind perechi, să de definească
; TDA-ul Complex (numere complexe), prin:
; - constructorul complex
; - operatorii real, imag, addC
;(define complex cons)
;(define real car)
;(define imag cdr)
;(define (addC c1 c2)
;  (complex (+ (real c1) (real c2))
;           (+ (imag c1) (imag c2))))
;(addC (complex 2 7) (complex 3 -3))


; ------------------Liste------------------
; constructori: null, cons, list
; selectori: car, cdr
; alte operații: null?, length, append
;(car (list 1 'a +))
;(cdr '(2 3 4 5))
;(null? '())
;(length (list))
;(append (cons 1 '(2)) '(a b))

; Ex: Reimplementare Complex folosind liste
;(define complex list)
;(define real car)
;(define imag second) ;există funcțiile first, second, third ...

;decomentează addC de mai sus
;(addC (complex 2 7) (complex 3 -3))
;Observă că implementarea addC nu se schimbă,
;întrucât folosește doar interfața (complex, real, imag).
;TDA in action!


; ------------------Valori booleene------------------
; constructori: #t, #f
; operatori: and, or, not
;(not (null? '(0)))
;(not 5)
;(and (= 3 4))
;(and 'a 'b)
;(and)
;(or #t (/ 1 0))
;(or 5 #t)
;(or)


; ------------------Operatori condiționali------------------
; (if conditie rez-then rez-else)
; (if (null? '(1))
;     (/ 1 0)
;     (- 7 1))

; (cond (cond1 rez1) (cond2 rez2) ... )
(define L '(1 2 3))
(define val
  (cond
    ((null? L)             0)
    ((null? (cdr L)) (/ 1 0))
    (else             'other)))
;val


; ------------------Recursivitate------------------
; Traducere din axiome:
; sum([])  = 0           ; suma elementelor din lista vidă este 0
; sum(x:l) = x + sum(l)  ; suma elementelor din lista cons(x,l) este x + suma elementelor din l

(define (sum L)
  (if (null? L)
      0
      (+ (car L) (sum (cdr L)))))
;(sum '(1 2 3))

; Ex: my-take
; L = '(1 2 3 4 5 6 7)       
; n = 4                      
; r = '(1 2 3 4)

; 1) După ce variabile fac recursivitatea?
;   (ce variabile își schimbă valoarea de la un apel la altul?)
; (my-take L n)

;- ajută (cdr L)?
;(cdr L) = '(2 3 4 5 6 7)
;Da, trebuie sa iau primele n-1 elemente din (cdr L)
;=> ambele variabile, L și n, se modifică în apelul recursiv
;-> '(2 3 4)

;Apoi?
;Mai trebuie sa adaug (car L) la inceput

; 2) Scrie condiția de oprire pentru fiecare asemenea variabilă
;   (constructori nulari și externi).
; axiome:
;my-take([], n) = []
;my-take(L, 0) = []

;(if (or (null? L) (zero? n))
;    '()

; 3) Scrie ce se întâmplă când problema nu este încă elementară
;   (constructori interni, care generează obligatoriu
;   cel puțin un apel recursiv).
; axiome:
;my-take(x:l, n) = x : my-take(l, n-1)

;     (cons (car L) (my-take (cdr L) (- n 1)))

(define (my-take L n)
  (if (or (null? L) (zero? n))
      '()
      (cons (car L) (my-take (cdr L) (- n 1)))))
;(my-take (range 2 10) 20)
;(my-take (range 2 10) 3)