;; !!! Limbajul trebuie să fie Pretty Big !!!

; ------------------Efecte laterale------------------
(define counter 1)

(define (display-and-inc-counter)
  (display counter)
  (set! counter (add1 counter))) ; nu folosiți set! în programele voastre!

;(display-and-inc-counter)
;(newline)
;(display-and-inc-counter)

;; Exemplu despre cum este posibil și util ca un n definit mai jos să fie vizibil mai sus:
(define a (λ () n))
(define n 5)
;(a)


; ------------------lambda------------------
(define test
  (λ (x y z)
    (display x)
    (if (< y 4)
        (test (add1 y) z z)) ; if fără else este posibil în limbajul Pretty Big
    z))

;(test 1 2 4)
;rulare pas cu pas
; display 1
; (test 3 4 4)
; display 3
; (test 3 4 4) intoarce 4 in neant
;(test 1 2 4) intoarce 4 

; ------------------let-uri------------------
(define x 2) ; să se încerce și cu linia asta comentată
;(let ((x 5) (y (add1 x))) ; x=5 y=3
;  (cons x y))
;
;(let* ((x (add1 x)) (y (add1 x)) (z (+ x y))) ; x=3, y=4, z=7
;  (list x y z))

;(letrec ((par? (λ (n) 
;                 (if (zero? n)
;                     #t
;                     (impar? (sub1 n)))))
;         (impar? (λ (n)
;                   (if (zero? n)
;                       #f
;                       (par? (sub1 n))))))
;  (par? 249))

;Ce face codul de mai jos?
;(define y 5)
;(letrec ((x y) (y 1)) x)

;; Named let oferă posibilitatea de a defini
;; și utiliza ad-hoc funcții helper
(define (fact-it n)
  (let loop ((n n) (acc 1))
    (if (zero? n)
        acc
        (loop (sub1 n) (* n acc)))))

(map fact-it '(1 2 3 4 5))

;; Ex: inversăm un număr folosind named let
(define (inversare nr)
  (let loop ((n nr) (inv 0))
    (display n)
    (display " ")
    (display inv)
    (newline)
    (if (zero? n)
        inv
        (loop (quotient n 10)
              (+ (* 10 inv)
                 (modulo n 10))))))

(inversare 5123)


; ------------------Legare dinamică------------------

; -----Funcții mutual recursive
; (alt exemplu pentru utilitatea de a vedea o funcție definită "mai jos")
(define par? (λ (n) 
                 (if (zero? n)
                     #t
                     (impar? (sub1 n)))))

(define impar? (λ (n) 
                 (if (zero? n)
                     #f
                     (par? (sub1 n)))))

;(impar? 5)

; -----Pierderea transparenței referențiale
(define (f)           
  (g 5))

(define (g x)        
  (* x x))
;(f)                  

;(define (g x)
;  (* x x x))
;(f)

; -----Programare în timp real
(define (server-loop)
  (display "g(5) = ")
  (display (g 5))
  (newline)
  (sleep 2)
  (server-loop))
;(server-loop)
;în timp ce rulează, modificăm g și apăsăm Run