anchor.diff:  ;; arrays of structures
   
   ;;
  -;; strings (fixed-width buffers)
  -;;
  -;; note that we don't have to concern ourselves with pointers
  -;; 
  +;; Strings (fixed-width buffers) are handled in a special (hacky) way
  +;; There should be a better way of doing it.
  +;;
  +;;
  +;; Note that we don't have to concern ourselves with pointers or anything like that.
  +;;
  +;; There is probably a better way of organising some of the code using generic functions,
  +;; particularly for packing/unpacking of the CLOS instances where it seems to make
  +;; the most sense. At the moment we generate a closure at definition time, but this could
  +;; in principle be done using a specialized generic function method.
  +;;
   ;;
   
   ;; alist of type definitions
  
positive.code: (defun %define-alias (alias name)
    "Define an alias for a type. Allows refering to the same type by a different name."
    (let ((type (get-type name)))
      (%define-type alias (type-packer type) (type-unpacker type) (type-size type))))
  
  (defun pack-uint8 (uint buffer start)
    "Pack an unsigned byted into the buffer."
  
negative.code:      (ieee-floats:decode-float64 bytes)))
    8)
  
  ;; booleans are really just uint32's
  (define-type :bool
    ((bool buffer start)
     (pack-type (if bool 1 0) :uint32 buffer start))
    ((buffer start)
     (let ((bool (unpack-type :uint32 buffer start)))
  	 (if (= bool 1)
  		 t
  		 nil)))
    4)
  	
  ;; This is a horrible hack. we need to have :string type defined so 
  ;; that we can compute the size of string-type slots, which are represented as arrays.
  ;; i.e. the size of (:string 12) should be 12.
  ;; We compute the size of arrays by multiplying the length of the array by the size of the base element.
  ;; We just alias :string to :uint8 so that we can get its size = 1.
  ;; the actual packing/unpacking is done by some special code in the closures
  ;; generated by %define-packet-type. There MUST be a better way of doing it!!!
  (define-alias :string :uint8)
  
  #|
  (define-type :string 
    ((string buffer start)
     (declare (ignore string buffer start))
     (error "This should never be called."))
    ((buffer start)
     (declare (ignore buffer start))
     (error "This should never be called."))
    1)
  |#
  ;; -----------------------------------------------------------
  
  
  (defun pack-type (object type buffer start)
  