#lang racket
(require racket/trace)

; recursiv pe stivă
(define (fact-1 n)
  (if (zero? n)
      1
      (* n (fact-1 (sub1 n)))
      ))

(trace fact-1)
(fact-1 5)

; folosiți Debug pentru a observa cum stiva nu se încarcă cu apeluri fact-2-aux
; după evaluarea lui (zero? n) cu n=0, întoarcerea se face direct la ieșirea din fact-2

; factorial recursiv pe coadă
(define (fact-2-aux n factorial)
  (if (zero? n)
      factorial
      (fact-2-aux (sub1 n) (* factorial n))
      ))
(define (fact-2 n) (fact-2-aux n 1))

(trace fact-2-aux)
(fact-2 5)

(member 7 '(1 2 3 4 5))
(member 3 '(1 2 3 4 3 5))

; este recursiv pe coadă, dar nu am
; nevoie de argument suplimentar / funcție auxiliară
(define (mem e L)
  (cond
    ((null? L) #f)
    ((equal? e (car L)) #t)
    (else (mem e (cdr L)))
    ))
(trace mem)
(mem 7 '(1 2 3 4 5))
(mem 3 '(1 2 3 4 3 5))

(define (mem-2 e L)
  (cond
    ((null? L) #f)
    ((equal? e (car L)) #t)
    (else (if (mem-2 e (cdr L)) #t #f)) ; forțez recursivitate pe stivă
    ))
(trace mem-2)
(mem-2 7 '(1 2 3 4 5))

; tot ce nu este exact #f este considerat adevărat
(if 0 'true 'false)
(if '() 'true 'false)
(if #f 'true 'false)

; and și or sunt funcții nestricte (nu evaluează toți parametrii)
(and 0 #t '() #f (/ 1 0) 'ceva)
(or #f 0 #t '() (/ 1 0) #f 'ceva)