(define area 
    (lambda (r) 
      (* 3.141592653 (* r r))))

(say (area 3))

(define fact 
    (lambda (n) 
      (if (<= n 1) 
	  1 
	  (* n (fact (- n 1))))))
; fact demo
(say (fact 10))
(say (fact 100))
(say (area (fact 10)))

; example of recursive function
(define first car)
(define rest cdr)
(define count 
    (lambda (item L) 
      (if L 
	  (+ (equal? item (first L)) 
	     (count item (rest L))) 
	  0)))

; demo of count
(say (count 0 (list 0 1 2 3 0 0)))

; assoc
(define nil (list))

(define assoc
    (lambda (x lst)
      (if lst
	  (if (equal? x (car (car lst)))
	      (car (cdr (car lst)))
	      (assoc x (cdr lst)))
	  nil)))

(define data (' ((name tim)
		 (age  53)
		 (gemder  m))))

(say (assoc (' name) data))
(say (assoc (' fred) data))

(define rightmost
    (lambda (x lst)
      (if lst
	  (cdr lst)
	      (rightmost x (cdr lst)))))


(define last
    (lambda (lst)
      (last1 (car lst) (cdr lst))))

(define last1
    (lambda (b4 now)
      (if now
	  (last now)
          b4)))

(say (last (' (a b c d e))))

(say (last (' (a))))

(define key
  (lambda (lst) 
    (car (car lst))))

(say 2)
(say (key (' ((zzz 1)))))
(say 3)

(say (list 2))

(define update ; adds pos if not already there
    (lambda (pos value lst)
      (begin 
       ;(say (list (' pos) pos 
;		  (' lst) (if lst (' some) (' none))))
       (if lst
	   (if (equal? pos (key lst))
	       (cons (list (key lst) value) (cdr lst))
	       (cons (car lst)     (update pos value (cdr lst))))
	   (list (list pos value))))))

(define data (' ((name tim)
		 (age  53)
		 (gemder  m))))	     
(say data)
(set! data (update (' name) (' george) data))
(say data)
(set! data (update (' mood) (' happy) data))
(say data)

; Function to find the double of any number
(define doubler (lambda (x) (* x 2)))
(say (doubler 5)) ; expect 10


; Make a function to check the equality of a number to the number 2
(define two (lambda (x) (= 2 x)))
(say (two 2)) ; expect t
(say (two 3)) ; expect nil

;4) Append a list to the front of a list
(define addon 
    (lambda (x lst) 
      (cons x lst)))

(say (addon (' beginning) nil))