"NEXT: Factorial. Recursive variant"

(define (fak0 n)
  (if (= n 0)
      1
      (* n (fak0 (- n 1)))))

(fak0 10)

"NEXT: Factorial. Iterative variant"

(define (fak1 n r)
  (if (= n 0)
      r
      (fak1 (- n 1) (* r n))))

(fak1 10 1)

"NEXT: Number intervals. Recursive variant"

(define (number-interval f t)
 (if (<= f t)
     (cons f (number-interval (+ f 1) t))
    '()))

(number-interval 1 10)
(number-interval 10 1)

"NEXT: Number intervals. Iterative variant"

(define (number-interval-iter f t)
  (reverse (number-interval-iter-help f t '())))


(define (number-interval-iter-help f t res)
  (if (<= f t)
      (number-interval-iter-help (+ f 1) t (cons f res))
      res))

(number-interval-iter 1 10)
(number-interval-iter 10 1)

"NEXT: String-merge. Recursive variant"

(define (string-merge str-list-1 str-list-2)
 (cond ((null? str-list-1) (apply string-append str-list-2))
       ((null? str-list-2) (apply string-append str-list-1))
       (else (string-append
              (car str-list-1) (car str-list-2)
              (string-merge (cdr str-list-1) (cdr str-list-2))))))   

(string-merge (list "a" "e") (list "b" "kat" "ten" "."))

"NEXT: String-merge. Iterative variant"

(define (string-merge-iter str-list-1 str-list-2)
 (merge-iter-helper  str-list-1 str-list-2 ""))

(define (merge-iter-helper str-list-1 str-list-2 res)
 (cond ((null? str-list-1) 
          (string-append res (apply string-append str-list-2)))
       ((null? str-list-2) 
          (string-append res (apply string-append str-list-1)))
       (else (merge-iter-helper
                (cdr str-list-1) 
                (cdr str-list-2)
                (string-append 
                    res (car str-list-1) (car str-list-2))))))

(string-merge-iter (list "a" "e") (list "b" "kat" "ten" "."))

"NEXT: STRING-OF-CHAR-LIST: ITERATIVE VARIANT"

(define (string-of-char-list? str char-list)
  (string-of-char-list-1? str char-list 0 (string-length str)))

(define (string-of-char-list-1? str char-list i lgt)
  (if (= i lgt)
      #t
      (and (memv (string-ref str i) char-list)
           (string-of-char-list-1? str char-list (+ i 1) lgt))))

(string-of-char-list? "abekat" (list #\a #\b #\e #\k  #\t))
(string-of-char-list? "abekat" (list #\a #\b))

"NEXT: EXPENSIVE RECURSIVE VARIANT"

(define (string-of-char-list? str char-list)
  (if (eqv? str "")
      #t
      (and (memv (string-ref str 0) char-list)
           (string-of-char-list? (substring str 1 (string-length str)) char-list))))

(string-of-char-list? "abekat" (list #\a #\b #\e #\k  #\t))
(string-of-char-list? "abekat" (list #\a #\b))

"NEXT: RECURSTION WITHOUT DEFINE OR LETREC:"

(let ((fac
         (lambda (n)
            (if (= n 1)
                1
                (* n (fac  (- n 1)))))))
  (fac 5)
)

((lambda (fac)
   (fac 5))
 (lambda (n)
   (if (= n 0) 1 (* n (fac  (- n 1)))))
)

; 3 different illustraton with letrec

(letrec ((fac (lambda (n)
                 (if (= n 0)
                     1
                     (* n (fac (- n 1)))))))
  (fac 5)
)

(let ((fac #f))
  (set! fac (lambda (n)
              (if (= n 0)
                  1
                  (* n (fac (- n 1))))))
  (fac 5)
)

; Self-passing idea:
(let ((fac (lambda (f n)
              (if (= n 0)
                  1
                  (* n (f f (- n 1)))))))
  (fac fac 5)
)

; Currying - compare to the final result using Y:
(let ((fac (lambda (f)
             (lambda (n)
               (if (= n 0)
                   1
                   (* n  ((f f) (- n 1))))))))
  ((fac fac) 5)
)

; Let rewritten to lambda
((lambda (fac) 
   ((fac fac) 5))
  (lambda (f)
    (lambda (n)
      (if (= n 0)
          1
          (* n  ((f f) (- n 1)))))))


; Introducing Y:
(let ((fac (Y (lambda (f)    
                (lambda (n) 
                   (if (= n 0) 
                       1
                       (* n (f (- n 1)))))))))
  (fac 5))

; Defining Y - as a mystery:
(define Y (lambda (j)
             (let ((i (lambda (f)               
                        (lambda (n)
                          ((j (f f)) n) ))))
               (i i))))

; Again:
(let ((fac (Y (lambda (f)    
                (lambda (n) 
                   (if (= n 0)
                       1
                       (* n (f (- n 1)))))))))
  (fac 5))

"THE END"