#lang racket
(require racket/trace)

(define mystery
  (lambda 'x 'x))

(define mystery2
  (lambda (quote x) 'x))

(define mystery1
  (lambda 'x quote))





(define fibonacci
  (lambda (n)
    (cond [(= n 1) 1]
	  [(= n 2) 1]
	  [else (+ (fibonacci (- n 1)) (fibonacci (- n 2)))])))
	  

(define fibonacciT
  (lambda (n current next)
    (cond [(= n 1) current]
	  [else (fibonacciT (- n 1) next (+ current next))])))



(define store '((2 . 1) (1 . 1)))

(define fib
  (lambda (n)
    (let ([value (assq n store)])
	(if value
	    (cdr value)
	    (let ([result (+ (fib (- n 1)) (fib (- n 2)))])
	      (set! store (cons (cons n result) store))
	      result)))))

(define fib-local
  (let ([local-store '((2 . 1) (1 . 1))])
    (letrec ([foo (lambda (n)
		    (let ([value (assq n local-store)])
		      (if value
			  (cdr value)
			  (let ([result (+ (foo (- n 1)) (foo (- n 2)))])
			    (set! local-store (cons (cons n result) local-store))
			    result))))])
      foo)))

;; also: with hash-table, to introduce them.
; (make-hash)
; (hash-set! ht key val)
; (hash-ref ht key [failure-result])

(define fib-hash
  (let ([local-store (make-hash)])
    (hash-set! local-store 1 1)
    (hash-set! local-store 2 1)
    (letrec ([foo (lambda (n)
		    (let ([value (hash-ref local-store n #f)])
		      (if value
			  value
			  (let ([result (+ (foo (- n 1)) (foo (- n 2)))])
			    (hash-set! local-store n result)
			    result))))])
      foo)))