; Collected Scheme code of Section 11.3 from
; Kenneth C. Louden, Programming Languages
; Principles and Practice 2nd Edition
; Copyright (C) Brooks-Cole/ITP, 2003

; page 485

(define a 2)

(define emptylist '())

(define (gcd u v)   ;	function name and parameters
  (if (= v 0)  ; function body
      u
      (gcd v (remainder u v))))

; Figure 11.7, pages 486-487
(define (euclid)
  (display "enter two integers:")
  (newline) ; goes to next line on screen
  (let ((u (read)) (v (read)))
    (display "the gcd of ")
    (display u)
    (display " and ")
    (display v)
    (display " is ")
    (display (gcd u v))
    (newline)))

; page 487

(define tree '("horse" ("cow" () ("dog" () ())) 
              ("zebra" ("yak" () ()) () )))

; page 489

(define (append L M)
  (if (null? L) M
      (cons (car L) (append (cdr L) M))))

(define (reverse L)
  (if (null? L) '()
      (append (reverse (cdr L)) (list (car L)))))

(define (leftchild B) (car ( cdr B)))
(define (rightchild B) (car (cdr (cdr B))))
(define (data B) (car B))

(define (print-tree B)
  (cond ((null? B) '() )
	(else (print-tree (leftchild B))
	      (display (data B))
	      (newline)
	      (print-tree (rightchild B)))))

; page 490

(define (square-list L)
  (if (null? L) '()
      (cons (* (car L) (car L)) (square-list (cdr L)))))

(define (print-squares low high)
  (cond ((> low high) '())
        (else (display (* low low))
              (newline)
              (print-squares (+ 1 low) high))))

(define (square-list1 L list-so-far)
  (if (null? L) list-so-far
      (square-list1 (cdr L)
             (append list-so-far (list (* (car L) (car L)))))))

; page 491

(define (square-list L) (square-list1 L '( )))

(define (reverse1 L list-so-far)
  (if (null? L) list-so-far
      (reverse1 (cdr L) (cons (car L) list-so-far))))

(define (reverse L) (reverse1 L '( )))

(define (map f L)
  (if (null? L) '()
      (cons (f (car L)) (map f (cdr L)))))

(define (sqr x) (* x x))

(define (square-list L) (map square L))

(define (make-double f)
  (define (doublefn x) (f x x))
  doublefn)

(define square (make-double *))
(define double (make-double +))

; page 492

(define square (lambda (x) (* x x)))

(define gcd (lambda (u v)
  (if (= v 0) u
      (gcd v (remainder u v)))))

(define (square-list L)
  (map (lambda (x) (* x x)) L))

; page 493

(let ((square (lambda (n) (* n n))))
	(display (square (read))))

(letrec ((fact (lambda (n) (if (= n 0) 1 
                               (* n (fact (- n 1)))))))
  (display (fact (read))))

(define (make-double f) (lambda (x) (f x x)))

(define (compose g f)
  (lambda (x) (g (f x))))

(define (make-new-balance balance)
   (lambda (amount)
	   (if (< balance amount) "Insufficient funds"
	   (begin
        (set! balance (- balance amount))
        balance)))) 

(define withdraw1 (make-new-balance 100))

(define withdraw2 (make-new-balance 100))

; page 494

(withdraw1 20)
(withdraw2 50)
(withdraw1 20)
(withdraw2 60)