anchor.diff:          (apply  fun (nconc (butlast args) arg-list))
           (reduce fun (nconc (butlast args) arg-list)))))
   
  -
   (defmacro while (condition &body body)
     "While loop."
     `(do () ((not ,condition))  ,@body))
   
  -
  -
   (defmacro until (condition &body body)
     "Until loop."
     `(do () (,condition)        ,@body))
  -
  -
   
   (defmacro for ((var first last &optional (step nil stepp)) &body body)
     "For loop.
  
positive.code:         This macro presents the same API as DEFSTRUCT, but instead of
          defining a structure, it defines a class, and the same functions
          as would be defined by DEFSTRUCT.
          The DEFSTRUCT options: :TYPE and :INITIAL-OFFSET are not supported.
  "
    (let (name options documentation slots slot-names accessors
          conc-name constructors copier
          include initial-offset predicate
          print-function print-object
          structure-type-p structure-type)
      (if (symbolp name-and-options)
          (setf name    name-and-options
                options nil)
          (setf name    (car name-and-options)
                options (cdr name-and-options)))
      (if (stringp (car doc-and-slots))
          (setf documentation (car doc-and-slots)
                slots         (cdr doc-and-slots))
          (setf documentation nil
                slots         doc-and-slots))
      (setf conc-name        (get-option :conc-name      options)
            constructors     (get-option :constructor    options :list)
            copier           (get-option :copier         options)
            predicate        (get-option :predicate      options)
            include          (get-option :include        options)
            initial-offset   (get-option :initial-offset options)
            print-function   (get-option :print-function options)
            print-object     (get-option :print-object   options)
            structure-type-p (get-option :type           options)
            structure-type   (get-option :type           options))
      (when (and print-object print-function)
        (error 'simple-program-error
               :format-control "Cannot have :print-object and :print-function options."))
      (when structure-type-p
        (unless (or (eql structure-type 'list)
                    (eql structure-type 'vector)
                    (and (listp structure-type)
                         (eql (first structure-type) 'vector)
                         (cdr structure-type)
                         (typep (second structure-type) '(integer 0))
                         (null (cddr structure-type))))
          (error 'simple-program-error
                 :format-control "Invalid structure :type option: ~S"
                 :format-arguments (list structure-type))))
      (when (cdr include)
        (setf slots   (append (cddr include) slots)
              include (list (car include))))
      (setf conc-name      (make-name conc-name ""      name "-")
            copier         (make-name copier    "COPY-" name "")
            predicate      (make-name predicate ""      name "-P")
            print-function (get-name print-function)
            print-object   (get-name print-object))
      (setf slot-names     (mapcar (lambda (s) (if (symbolp s) s (car s))) slots))
      (setf accessors      (mapcar (lambda (s) (make-name nil (or conc-name "")
                                                          (if (symbolp s) s (car s)) ""))
                                   slots))
      (setf constructors   (if (null constructors)
                               (list (make-name nil "MAKE-" name ""))
                               (mapcan (lambda (x)
                                         (cond
                                           ((or (symbolp x) (= 1 (length x)))
                                            (list (make-name nil "MAKE-" name "")))
                                           ((null (second x))
                                            nil)
                                           ((= 2 (length x))
                                            (list (second x)))
                                           (t
                                            (list (list (second x) (third x))))))
                                       constructors)))
      (funcall (cond ((not structure-type-p)     (function generate-class-structure))
                     ((eql structure-type 'list) (function generate-list-structure))
                     (t                          (function generate-vector-structure)))
               name options documentation
               slots slot-names accessors
               conc-name constructors copier
               include initial-offset predicate
               print-function print-object
               structure-type-p structure-type)))
  
  
  
  (defmacro define-with-object (class-name slots)
    "
  
negative.code:               ((funcall ,cmp ,var ,lastvar))
              ,@body))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; 7 - OBJECTS
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  (defmacro pjb-defclass (name super &rest args)
    "
  