anchor.diff:    (when (column-output-record-p record)
       (error "Trying to add a column into a row table.")))
   
  -(defmethod table-cell-spacing ((table table-of-rows-output-record))
  -  (slot-value table 'x-spacing))
  -(defmethod table-block-spacing ((table table-of-rows-output-record))
  -  (slot-value table 'y-spacing))
  +(defmethod table-cell-spacing ((table table-of-rows-output-record) stream)
  +  (parse-space stream (slot-value table 'x-spacing) :horizontal))
  +(defmethod table-block-spacing ((table table-of-rows-output-record) stream)
  +  (parse-space stream (slot-value table 'y-spacing) :vertical))
  +
  +(defmethod table-equalize-column-widths ((table table-of-rows-output-record)
  +                                         block-infos widths)
  +  (declare (ignore table block-infos)
  +           (type (vector coordinate) widths))
  +  (let ((max-width
  +         (loop :for w :across widths
  +               :maximize w)))
  +    (dotimes (i (length widths))
  +      (setf (aref widths i) max-width))))
   
   ;;; Table of columns
   (defclass table-of-columns-output-record (standard-table-output-record)
  
positive.code: 
  (defmethod adjust-table-cells ((table-record standard-table-output-record)
                                 stream)
    (let* ((cell-spacing (table-cell-spacing table-record))
           (block-spacing (table-block-spacing table-record))
           (infos (collect-block-infos table-record))
           (max-block-length (loop :for info :in infos
                                   :maximize (block-info-number-of-cells info)))
           (sizes (make-array (list max-block-length)
                              :element-type 'coordinate
                              :initial-element (coerce 0 'coordinate))))
      (loop :for info :in infos
            :for block-sizes = (block-info-cell-sizes info)
            :do (loop :for i = 0 :then (1+ i)
                      :for s :in block-sizes
                      :do (setf (aref sizes i)
                                (max (aref sizes i) s))))
      (map-over-table-elements
       (let ((common-coordinate (coerce 0 'coordinate)))
         #'(lambda (block)
             (let ((common-size (block-info-common-size (pop infos))))
               (adjust-block block (coerce sizes 'list)
                             cell-spacing common-coordinate common-size)
               (incf common-coordinate (+ common-size block-spacing)))))
       table-record
  
negative.code: 
  (defun block-info (block)
    "Returns information about the BLOCK in struct BLOCK-INFO."
    (declare (type block-output-record block))
    (let ((info (make-instance 'block-info)))
      (with-slots (common-size number-of-cells cell-sizes) info
                  (map-over-block-cells
  