anchor.diff:    (with-input-from-string (stream string)
       (unmarshal (read stream))))
   
  +;; write svar (shared variable) to remote server
  +(defmacro force-write-svar (var-name &key (host nil hostp) (port nil portp))
  +  (append `(xml-rpc-call 
  +	    (encode-xml-rpc-call "OVERWRITE_SVAR" (obj->string 
  +						   (list ',var-name ,var-name))))
  +	  (when hostp (list :host host))
  +	  (when portp (list :port port))))
  +
  +(defun overwrite_svar (str)
  +  (let* ((*package* *binded-package*)
  +	 (unmarshaled (string->obj str))
  +	 (symbol (intern (symbol-name (car unmarshaled)) *package*)))
  +    (setf (symbol-value symbol) (cadr unmarshaled))
  +    str))
  +
  +;; pfun is for "portable function"
   (defmacro def-pfun (name args &body body)
     `(progn 
        (declaim (notinline ,name))
  
positive.code: (defun receive_pfun (pfun-str)
    (let* ((*package* *binded-package*)
  	 (unmarshaled (string->obj pfun-str)) 
  	 (symbol (intern (symbol-name (function-name unmarshaled)) :func-dispatch)))
      (update-funcallable-function unmarshaled)
      (setf (symbol-function symbol) unmarshaled)
      pfun-str))
  
negative.code:     (set-funcallable-instance-function obj (compile nil definition))))
  
  (defmethod (setf function-definition) :after ((obj function-with-definition) func-def)
    (unless (eql nil func-def) 
      (set-funcallable-instance-function obj (compile nil func-def))))
  
  (defmethod update-funcallable-function ((obj function-with-definition))
    (let ((lambda-def (function-definition obj)))
  