(class Stack Object
  (elems)
  (define initStack ()
    (begin
	(set elems (mkList))
	self))
  (define push: (x) (add: elems x))
  (define pop () (removeFirst elems))
  (define top () (car elems))
  (define isEmpty () (isEmpty elems))
  (define print ()
    (begin
      (print #Stack)
      (printAux self (first elems))))
  (define printAux (e)
    (begin
      (while (notNil e)
	(begin
	  (print e)
	  (set e (next elems))))
      self))
)
(define mkStack ()
  (initStack (new Stack)))

(set myStack (mkStack))

(class SizedStack Stack
  (size)
  (define initSizedStack ()
    (begin
      (initStack self)
      (set size 0)
      self))
  (define size () size)
  (define push: (x)
    (begin
      (set size (+ 1 size))
      (add: elems x)))
  (define pop ()
    (begin
      (set size (- 1 size))
      (removeFirst elems))) 
)
(define mkSizedStack ()
  (initSizedStack (new SizedStack)))

(set sStack (mkSizedStack))

	Steps in message sending:

let receiver = object that is sent message
let c = class of receiver

1. [fetch] look for method in class c
   found: go to step 2
   not found: if c is Object give error,
      else goto 1.

2. [call] bind formals to actuals
    and execute the code of the method



(define assignMyStack (b)
   (if b
	(set myStack (mkStack))
	(set myStack (mkSizedStack))))

(push: myStack 4)

Smalltalk		CLU

(xCord yCord)		(rep xCord yCord)
(set xCord x) 		(set-xCord p x)
xCord			(xCord p)
self			p
(define rotate ()	(define rotate (p) 
   ... self...)		   ...p ...)


(class CachedStack Stack
  (cache)
  (define initCachedStack ()
    (begin
      (initStack self)
      (set cache #nil)
      self))
  (define push: (anElem)
    (if (notNil cache)
        (begin
	  (add: elems cache)
	  (set cache anElem))
	(set cache anElem)))
  (define pop ()
    (if (isNil cache)
        (removeFirst elems)
	(set cache #nil)))
  (define top ()
    (if (notNil cache)
        cache
        (car elems)))
  (define isEmpty ()
    (and (isNil cache) (isEmpty elems)))
  (define print ()
    (begin
      (print #Stack)
      (if (notNil cache)
          (print cache)
	  0)
      (printAux self (first elems))))
)
(define mkCachedStack ()
  (initCachedStack (new CachedStack)))