anchor.diff:  
   ;;; Also implementation dependent.
   (defmethod to-string ((this -date-prototype))
  -  (-to-date-string (slot-value this '-date-value)))
  +  (to-date-string this))
   
   (defmethod to-time-string ((this -date-prototype))
  -  )
  +  (to-date-string this))
   
   (defmethod to-utc-string ((this -date-prototype))
  -  )
  +  (let ((ts (slot-value this '-date-value)))
  +    (when (eql ts :nan)
  +      (return-from to-utc-string (!string "Invalid Date")))
  +    (!string (format-rfc1123-timestring nil ts :timezone +utc-zone+))))
   
   (defmethod value-of ((this -date-prototype))
  -  (slot-value this '-date-value))
  +  (let ((ts (slot-value this '-date-value)))
  +    (when (eql ts :nan)
  +      (return-from value-of *number-nan*))
  +    (let ((nano (nsec-of ts)))
  +      (!number (+ (* 1000 (timestamp-to-unix ts)) (floor nano 1000000))))))
   
   (defmethod to-primitive ((this -date-prototype) hint)
  -  )
  +  (case hint
  +    ((default string)
  +     (-to-primitive this 'string))
  +    ('number
  +     (-to-primitive this 'number))
  +    (t
  +     (error "Type error."))))
  
positive.code:       (let ((dt (if date (slot-value (-to-number date) '-number-data) dd)))
  	(when (or (eql m :nan) (eql dt :nan))
  	  (error "Reference error."))
  	(when (or (eql ts :nan) (eql m :infinity) (eql m :-infinity)
  		  (eql dt :infinity) (eql dt :-infinity))
  	  (return-from set-month *number-nan*))
  	(setf (slot-value this '-date-value)
  	      (adjust-timestamp! ts (offset :month m :day dt)))
  	(* 1000 (timestamp-to-unix ts))))))
  
  (defmethod set-seconds ((this -date-prototype) sec &optional ms)
    (let ((ts (slot-value this '-date-value))
  	(s (slot-value (-to-number sec) '-number-data)))
      (multiple-value-bind
  	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts)
        (let ((nano (if ms (* 1000000 (slot-value (-to-number ms) '-number-data))
  		      ns)))
  	(setf (slot-value this '-date-value)
  	      (adjust-timestamp! ts (offset :sec s :nsec nano)))
  	(* 1000 (timestamp-to-unix ts))))))
  
  (defmethod set-time ((this -date-prototype) time)
    (let* ((tm (slot-value (-to-number time) '-number-data))
  	 (nano (* 1000000 (mod tm 1000))))
      (setf (slot-value this '-date-value) (unix-to-timestamp tm :nsec nano))
      tm))
  
  (defmethod set-utc-date ((this -date-prototype) date)
    (let ((ts (slot-value this '-date-value))
  	(dt (slot-value (-to-number date) '-number-data)))
      (multiple-value-bind
  	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts :timezone +utc-zone+)
        (setf (slot-value this '-date-value)
  	    (adjust-timestamp! ts (offset :day date))))
      (* 1000 (timestamp-to-unix ts))))
  
  (defmethod set-utc-full-year ((this -date-prototype) year &optional month date)
    (let ((tm (slot-value this '-date-value))
  	(y (-to-number year))
  	(m (if month (-to-number month) (count-month tm)))
  	(dt (if date (-to-number date) (count-date tm))))
      ))
  
  (defmethod set-utc-hours ((this -date-prototype) hour &optional min sec ms)
    (let ((tm (slot-value this '-date-value))
  	(h (-to-number hour))
  	(m (if min (-to-number min) (count-minute tm)))
  	(s (if sec (-to-number sec) (count-second tm)))
  	(milli (if ms (-to-number ms) (count-ms tm))))
      ))
  
  (defmethod set-utc-milliseconds ((this -date-prototype) ms)
    (let ((tm (slot-value this '-date-value))
  	(milli (-to-number ms)))
      ))
  
  (defmethod set-utc-minutes ((this -date-prototype) min &optional sec ms)
    (let ((tm (slot-value this '-date-value))
  	(m (-to-number min))
  	(s (if sec (-to-number sec) (count-second tm)))
  	(milli (if ms (-to-number ms) (count-ms tm))))
      ))
  
  (defmethod set-utc-month ((this -date-prototype) month &optional date)
    (let ((tm (slot-value this '-date-value))
  	(m (-to-number month))
  	(dt (if date (-to-number date) (count-date tm))))
      ))
  
  (defmethod set-utc-seconds ((this -date-prototype) sec &optional ms)
    (let ((tm (slot-value this '-date-value))
  	(s (-to-number sec))
  	(milli (if ms (-to-number ms) (count-ms tm))))
      ))
  
  ;;; Implementation dependent. Use form in LOCAL-TIME pack.
  (defmethod to-date-string ((this -date-prototype))
    )
  
  (defmethod to-iso-string ((this -date-prototype))
    )
  
  ;;; How to implement this?
  (defmethod to-json ((this -date-prototype) key)
  
negative.code:     (multiple-value-bind
  	  (ns ss mm hh dd mon yy day-of-weak daylight-saving-time-p timezone-offset timezone-abbr) (decode-timestamp ts)
        (let* ((s (if sec (slot-value (-to-number sec) '-number-data) ss))
  	     (milli (if ms (slot-value (-to-number ms) '-number-data) ns))
  	     (nano (if (eql milli :nan)
  		       :nan
  		       (if (or (eql milli :infinity) (eql milli :-infinity))
  			   :infinity milli))))
  	(when (or (eql m :nan) (eql s :nan) (eql nano :nan))
  	  (error "Reference error."))
  	(when (or (eql m :infinity) (eql m :-infinity) (eql s :infinity)
  		  (eql s :-infinity) (eql nano :infinity))
  	  (setf (slot-value this '-date-value :nan))
  	  (return-from set-minutes *number-nan*))
  	(setf (slot-value this '-date-value)
  	      (adjust-timestamp! ts (offset :minute m :sec s :nsec nano)))
  	(!number (* 1000 (timestamp-to-unix ts)))))))
  
  (defmethod set-month ((this -date-prototype) month &optional date)
    (let ((ts (slot-value this '-date-value))
  