#lang racket
(define pythagoras
  (lambda (x y)
    (let ([x-squared (* x x)]
          [y-squared (* y y)])
      (sqrt (+ x-squared y-squared)))))

(define pythagorasL
  (lambda (x y)
    ((lambda (x-squared y-squared)
       (sqrt (+ x-squared y-squared)))
     (* x x)
     (* y y))))

;(define hmm
;  (lambda (l)
;    (let ([a (car l)]
;          [b (cdr l)]
;          [c (car b)])
;      (list c a))))

;(define hmmL
;  (lambda (l)
;    ((lambda (a b c)
;      (list c a))
;     (car l)
;     (cdr l)
;     (car b))))

(define hmm*
  (lambda (l)
    (let* ([a (car l)]
           [b (cdr l)]
           [c (car b)])
      (list c a))))

(define hmm*L
  (lambda (l)
    ((lambda (a)
       ((lambda (b)
          ((lambda (c)
             (list c a))
           (car b)))
          (cdr l)))
       (car l))))

;(define fac
;  (lambda (n)
;    (fac-tail n 1)))

;(define fac-tail
;  (lambda (n acc)
;    (if (= n 1)
;        acc
;        (fac-tail (- n 1) (* n acc)))))

;(define facLet
;  (lambda (n)
;    (let ([fac-tail
 ;           (lambda (n acc)
 ;             (if (= n 1)
  ;                acc
  ;                (fac-tail (- n 1) (* n acc))))])
  ;    (fac-tail n 1))))

;(define facLetLambda
;  (lambda (n)
;    ((lambda (fac-tail)
;      (fac-tail n 1))
;     (lambda (n acc)
;       (if (= n 1)
;           acc
;           (fac-tail (- n 1) (* n acc)))))))

(define facLetRec
  (lambda (n)
    (letrec ([fac-tail
              (lambda (n acc)
                (if (= n 1)
                    acc
                    (fac-tail (- n 1) (* n acc))))])
      (fac-tail n 1))))

(define facNamedLet
  (lambda (n)
    (let foo ([x n]
              [acc 1])
      (if (= x 1)
          acc
          (foo (- x 1) (* x acc))))))

(define my-add
  (lambda l
    (my-add-helper l)))
(define my-add-helper
  (lambda (l)
    (if (null? l)
        0
        (+ (car l) (my-add-helper (cdr l))))))