anchor.diff:  	  *boolean-true*)))
   
   (defun -object.keys (object)
  -  )
  +  (let ((obj (-to-object object))
  +	(name-list nil))
  +    (dolist (key-value (properties obj))
  +      (let ((prop (cdr key-value))
  +	    (key (car key-value)))
  +	(when (eql (property-enumerable prop) :true)
  +	  ;; Here the key are raw Lisp symbols, how to handle them?
  +	  (push key name-list))))
  +    (!array name-list)))
   
   (defun -object.prevent-extensions (object)
     (if (not (eql (-type object) 'object-type))
  
positive.code: ;;; I don't know what does the standard mean!
  (defmethod %to-string ((this -object-proto) &optional radix)
    (declare (ignore radix))
    )
  
  (defmethod %value-of ((this -object-proto))
    (-to-object this))
  
negative.code: (defun -object.get-prototype-of (object)
    (-get-prototype-of object))
  
  (defun same-value (x y)
    (when (not (eql (-type x) (-type y)))
      (return-from same-value *boolean-false*))
    (typecase x
      (undefined-type
       *boolean-true*)
      (null-type
       *boolean-true*)
      (number-type
       (if (eql x y)
  	 *boolean-true*
  	 (if (= (slot-value x '-number-data) (slot-value y '-number-data))
  	     *boolean-true*
  	     *boolean-false*)))
      (string-type
       (if (string= (slot-value x '-string-data) (slot-value y '-string-data))
  	 *boolean-true*
  	 *boolean-false*))
      (boolean-type
       (if (eql x y)
  	 *boolean-true*
  	 *boolean-false*))
      (symbol-type
       (if (eql (slot-value x '-symbol-data) (slot-value y '-symbol-data))
  	 *boolean-true*
  	 *boolean-false*))
      (object-type
       (if (eql x y)
  	 *boolean-true*
  	 *boolean-false*))))
  
  (defun -object.is (value1 value2)
    (same-value value1 value2))
  
  (defun -object.is-extensible (object)
    (if (eql (-is-extensible object) :false)
  