(define powsum
  ; Takes a list of natural numbers.  Returns the sum of powers 2^n where 
  ; n ranges over elements of lon.
  (lambda (lon)
    (cond [(null? lon) 0]
          [else (+ (expt 2 (car lon)) (powsum (cdr lon)))])))

(define (sum xs) 
  (cond [(null? xs) 0]
        [else (+ (car xs) (sum (cdr xs)))]))

(define (sumT xs) (sumLoop xs 0)) 

(define (sumLoop xs n) 
  (cond [(null? xs) n]
        [else (sumLoop (cdr xs) (+ (car xs) n))]))

(define test-sum
  (and (equal? (sum '(99 83 2)) (sumT '(99 83 2)))
       (equal? (sum '()) (sumT '()))))

(define (my-reverse xs)
  (cond [(null? xs) xs]
        [else (append (my-reverse (cdr xs)) (list (car xs)))]))

(define (my-reverse-fast xs)
  (rev xs '()))


(define (rev xs ys)
  (cond [(null? xs) ys]
        [else (rev (cdr xs) (cons (car xs) ys))]))

(define (long n) ; list of n elements
  (cond [(eqv? n 0) '()]
        [else (cons n (long (- n 1)))]))

; For performance testing, we don't want to be biased by
; the time taken for display of results.  So display a single
; number.
; Evaluate
; (length (my-reverse      (long 100000))))
; (length (my-reverse-fast (long 100000))))
 
(define (fib n)
  (cond [(or (eqv? n 0) (eqv? n 1)) n]
        [else (+ (fib (- n 1)) (fib (- n 2)))]))

(define (list-pos x xs)
  (cond [(null? xs) -1]
        [else (cond [(eqv? x (car xs)) 0]
                    [(eqv? -1 (list-pos x (cdr xs))) -1]
                    [else (+ 1 (list-pos x (cdr xs)))])]))