anchor.diff:  (defchannel-recipient-slots ordered
       ((ordered-sequence-number :accessor ordered-sequence-number-of
                                 :initform 0)))
  +
  +(defchannel-packet-slots ordered
  +    ((ordered-sequence-number :accessor ordered-sequence-number-of)))
   
   (defun next-ordered-sequence-number (channel recipient)
     (let ((n (1+ (ordered-sequence-number-of recipient))))
  
positive.code:        :unless (fboundp (cadr pair))
         :collecting `(defgeneric ,(cadr pair) (instance)))))
  
  (defmacro defchannel-slots (name slots &rest rest)
    (let ((component (gensym "COMPONENT-")))
      `(eval-when (:compile-toplevel :load-toplevel :execute)
         (let ((,component (ensure-component ',name)))
           ,@(reduce #'append (mapcar #'ensure-slot-generics slots))
           (setf (slots-of ,component) ',slots
                 ,@(awhen (rest (assoc :default-initargs rest))
                     `((initargs-of ,component) ',it)))))))
  
  (defmacro defchannel-recipient-slots (name slots &rest rest)
    (declare (ignore name rest))
    `(progn ,@(reduce #'append (mapcar #'ensure-slot-generics slots))))
  
  (defmacro defchannel-packet-slots (name slots &rest rest)
    (declare (ignore name rest))
    `(progn ,@(reduce #'append (mapcar #'ensure-slot-generics slots))))
  
  (defmacro defchannel-encoder (name (channel recipient payload) &body body)
    (declare (ignore name channel recipient payload body)))
  
  (defmacro defchannel-decoder (name (channel recipient packet) &body body)
    (declare (ignore name channel recipient packet body)))
  
  (defchannel-slots ordered
      ((max-sequence-number :initarg :max-sequence-number
                            :reader max-sequence-number-of))
  
negative.code:   (defvar *channel-components* (make-hash-table)))
  
  (defclass channel-component ()
    ((channel-slots :accessor channel-slots-of
                    :initform nil)
     (channel-initargs :accessor channel-initargs-of
                       :initform nil)
     (recipient-slots :accessor recipient-slots-of
                      :initform nil)
     (recipient-initargs :accessor recipient-initargs-of
                         :initform nil)
     (packet-slots :accessor packet-slots-of
                   :initform nil)
     (packet-initargs :accessor packet-initargs-of
                      :initform nil)
     (encoder-args :accessor encoder-args-of
                   :initform nil)
     (encoder-body :accessor encoder-body-of
                   :initform nil)
     (decoder-args :accessor decoder-args-of
                   :initform nil)
     (decoder-body :accessor decoder-body-of
                   :initform nil)
     (fragmenter-args :accessor fragmenter-args-of
                      :initform nil)
     (fragmenter-body :accessor fragmenter-body-of
                      :initform nil)))
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defun ensure-component (name)
  