;; ATENȚIE!
;; Pentru a rula aceste exemple, alegeți Language/Other languages/Pretty Big

;; true e o funcție binară care întoarce mereu primul argument
;; false ... pe al doilea
(define true-0 (λ (x y) x))
(define false-0 (λ (x y) y))

;; not(T) = F   not(F) = T
(define not-0 (λ (x) (x false-0 true-0)))
;; and(T, y) = y   and(F, y) = F
(define and-0 (λ (x y) (x y false-0)))
;; or(T, y) = T   or (F, y) = y
(define or-0 (λ (x y) (x true-0 y)))

;; if(T, x, y) = x   if(F, x, y) = y
(define-syntax if-0
  (syntax-rules ()
    (  (_ pred true-exp false-exp)
       ;; când pred = T, se întoarce (λ () true-exp) aplicat pe 0 argumente
       ;; astfel if rămâne o funcție nestrictă
       ( (pred (λ () true-exp) (λ () false-exp)))  )))

(define cons-0 (λ (x y) (λ (z) (z x y))))
;; car(cons(x,y)) = ((λ (z) (z x y)) T) = (T x y) = x
(define car-0 (λ (L) (L true-0)))
;; cdr(cons(x,y)) = ((λ (z) (z x y)) F) = (F x y) = y
(define cdr-0 (λ (L) (L false-0)))

(define null-0 (λ (x) true-0))
;; null?(null) = (null (λ (x y) false-0)) = T
;; null?(cons(x,y)) = ((λ (z) (z x y)) (λ (x y) false-0)) = F
(define null-0? (λ (x) (x (λ (x y) false-0))))

(define (append-0 A B)
  (if-0 (null-0? A)
        B
        (cons-0 (car-0 A) (append-0 (cdr-0 A) B))))

(define (list-0->std L)
  (if-0 (null-0? L)
        '()
        ;; când returnăm folosim '() și cons pentru că facem conversia
        ;; în liste standard, doar pentru vizualizare
        (cons (car-0 L) (list-0->std (cdr-0 L)))))

;(append-0 (cons-0 'x null-0) (cons-0 'y (cons-0 'z null-0)))
;(list-0->std (append-0 (cons-0 'x null-0) (cons-0 'y (cons-0 'z null-0))))

(define zero-0 null-0)
(define (succ-0 n) (cons-0 'unit n))
(define pred-0 cdr-0)
(define zero-0? null-0?)

(define (take-0 L n)
  (if-0 (or-0 (null-0? L) (zero-0? n))
        null-0
        (cons-0 (car-0 L) (take-0 (cdr-0 L) (pred-0 n)))))

(list-0->std (take-0 (cons-0 'x (cons-0 'y (cons-0 'z (cons-0 't null-0))))
                     (succ-0 (succ-0 (succ-0 zero-0)))))
(list-0->std (take-0 (cons-0 'x (cons-0 'y (cons-0 'z (cons-0 't null-0))))
                     (succ-0 (succ-0 (succ-0 (succ-0 (succ-0 zero-0)))))))