#lang racket
(require racket/trace)


(define (sumList L)
  (if (null? L)
      0
      (+ (car L) (sumList (cdr L))) ; rezultatul apelului recursiv este argument pentru alt apel
      ))
(trace sumList)
(sumList '(1 2 3 4 5))


(define (sumList2 L) (sumList-H L 0))
(define (sumList-H L sumPart)
  (if (null? L)
      sumPart
      (sumList-H (cdr L)
                 (+ sumPart (car L))) ; rezultatul apelului recursiv este întors direct de apelul curent
      ))
(trace sumList2)
(trace sumList-H)
(sumList2 '(1 2 3 4 5))


(define (sumList3 L . args) ; args este 'lista celorlalte argumente'
  (let ((sumPart (if (null? args) 0 (car args))))
    (if (null? L)
        sumPart
        (sumList3 (cdr L) (+ sumPart (car L)))
        )))
(trace sumList3)
(sumList3 '(1 2 3 4 5))


(define (mem e L) ; este recursiv pe coadă dar nu am nevoie de argument suplimentar
  (cond
    [(null? L) #f]
    [(equal? e (car L))]
    [else (mem e (cdr L))]
    ; pot folosi condiția #t în loc de else
    ))
(mem 3 '(1 2 3 4 5))
(mem 6 '(1 2 3 4 5))


; am mai multe apeluri recursive dar sunt pe ramuri diferite
(define (evens L)
  (cond
    [(null? L) null]
    [(even? (car L))
     (cons (car L) (evens (cdr L)))]
    [else (evens (cdr L))]
    ))


; am mai multe apeluri recursive dar fac parte din același apel
(define (fib n)
  (if (<= n 1)
      n
      (+ (fib (- n 1))
         (fib (- n 2)))
      ))
(trace fib)
(fib 4)

; tupling, fără match
; recursiv pe stivă
(define (fib-tp1 n)
  (if (zero? n)
      (cons 0 1)
      (let* ([res (fib-tp1 (sub1 n))]
             [fn-1 (car res)]
             [fn (cdr res)]
             ) ; folosesc o formă de let ca să nu am nevoie de mai multe apeluri
        (cons fn (+ fn-1 fn))
        )
      ))
(fib-tp1 4)      

; tupling, cu match
; recursiv pe stivă
(define (fib-tp n)
  (if (zero? n)
      (cons 0 1)
      ; (fib-tp (sub1 n)) -> (fn-1 fn)
      (match (fib-tp (sub1 n)) ; fac un apel
        [(cons fn-1 fn) ; dacă rezultatul apelului
         ; ar putea să fi fost construit cu acest cons,
         ; atunci leagă fn-1 și fn corespunzător
         (cons fn (+ fn-1 fn))]
        )))
(fib-tp 4)