anchor.diff:  
   (defmethod transform-region (transformation (path bezier-curve))
     (make-instance 'bezier-curve
  -    :segments (mapcar (lambda (segment)
  -			(transform-segment transformation segment))
  -	       (%segments path))))
  +                 :segments (let ((segments (%segments path)))
  +                             (map (type-of segments)
  +                                  (lambda (segment)
  +                                    (transform-segment transformation segment))
  +                                  (%segments path)))))
   
   (defmethod region-union ((r1 bezier-curve) (r2 bezier-curve))
     (let ((p (slot-value (car (last (%segments r1))) 'p3))
  
positive.code:     (if (region-equal p (slot-value seg 'p0))
  	(with-slots (p1 p2 p3) seg
  	  (make-instance 'bezier-curve
  	    :segments (append (%segments r1)
  		       (cons (make-bezier-segment p p1 p2 p3)
  			     (cdr (%segments r2))))))
  	(call-next-method))))
  
  ;;; an area defined as a closed path of Bezier curve segments
  
negative.code:                      y-offset p1y)
              append  (list c0x c0y c1x c1y p1x p1y))))
  
  (defun point-seq-to-segment-seq (point-seq)
    (destructuring-bind (leftover segment-seq)
     (reduce (lambda (acc point)
               (destructuring-bind (build vec)
                   acc
                 (if (= (length build) 3)
                     (progn
                       (vector-push-extend
                        (make-instance 'mcclim-bezier::bezier-segment
                                       :p0 (third build)
                                       :p1 (second build)
                                       :p2 (first build)
                                       :p3 point)
                        vec)
                       (list (list point) vec))
                     (list (cons point build) vec))))
             point-seq
             :initial-value (list nil (make-array 4 :fill-pointer 0)))
      (unless (equal (length leftover) 1)
        (error "Invalid point-seq: ~S ~S" point-seq leftover))
      segment-seq))
  
  (defun coord-seq-to-point-seq (coord-seq)
    (destructuring-bind (leftover coord-seq)
     (reduce (lambda (acc coord)
               (destructuring-bind (build vec)
                   acc
                 (if (= (length build) 1)
                     (progn
                       (vector-push-extend (make-point (car build) coord) vec)
                       (list nil vec))
                     (list (cons coord build) vec))))
             coord-seq
             :initial-value (list nil (make-array 4 :fill-pointer 0)))
     (if leftover
         (error "Invalid coord-seq: ~S" coord-seq)
         coord-seq)))
  
  (defun make-bezier-thing (class point-seq)
    (assert (= (mod (length point-seq) 3) 1))
    (make-instance class :segments (point-seq-to-segment-seq point-seq)))
  
  (defun make-bezier-thing* (class coord-seq)
    (assert (= (mod (length coord-seq) 6) 2))
    (make-bezier-thing class (coord-seq-to-point-seq coord-seq)))
  
  (defun make-bezier-curve (point-seq)
    (make-bezier-thing 'bezier-curve point-seq))
  