cedet-eieio

[cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

Here is a patch that attempts to clean up part of the EIEIO namespace.
If you like it, please install it upstream, so it will get merged into
Emacs later on.  If you prefer, I can install it into Emacs directly and
you'll merge it later on upstream, of course.


        Stefan


=== modified file 'lisp/emacs-lisp/eieio-base.el'
--- lisp/emacs-lisp/eieio-base.el	2013-01-01 09:11:05 +0000
+++ lisp/emacs-lisp/eieio-base.el	2013-01-17 18:10:13 +0000
@@ -65,19 +64,19 @@
   "Clone OBJ, initializing `:parent' to OBJ.
 All slots are unbound, except those initialized with PARAMS."
   (let ((nobj (make-vector (length obj) eieio-unbound))
-	(nm (aref obj object-name))
+	(nm (eieio--object-name obj))
 	(passname (and params (stringp (car params))))
 	(num 1))
     (aset nobj 0 'object)
-    (aset nobj object-class (aref obj object-class))
+    (setf (eieio--object-class nobj) (eieio--object-class obj))
     ;; The following was copied from the default clone.
     (if (not passname)
 	(save-match-data
 	  (if (string-match "-\\([0-9]+\\)" nm)
 	      (setq num (1+ (string-to-number (match-string 1 nm)))
 		    nm (substring nm 0 (match-beginning 0))))
-	  (aset nobj object-name (concat nm "-" (int-to-string num))))
-      (aset nobj object-name (car params)))
+	  (setf (eieio--object-name nobj) (concat nm "-" (int-to-string num))))
+      (setf (eieio--object-name nobj) (car params)))
     ;; Now initialize from params.
     (if params (shared-initialize nobj (if passname (cdr params) params)))
     (oset nobj parent-instance obj)
@@ -232,8 +231,7 @@
 being pedantic."
   (unless class
     (message "Unsafe call to `eieio-persistent-read'."))
-  (when (and class (not (class-p class)))
-    (signal 'wrong-type-argument (list 'class-p class)))
+  (when class (eieio--check-type class-p class))
   (let ((ret nil)
 	(buffstr nil))
     (unwind-protect
@@ -308,7 +306,7 @@
 	       (type nil)
 	       (classtype nil))
 	   (setq slot-idx (- slot-idx 3))
-	   (setq type (aref (aref (class-v class) class-public-type)
+	   (setq type (aref (eieio--class-public-type (class-v class))
 			    slot-idx))
 
 	   (setq classtype (eieio-persistent-slot-type-is-class-p
@@ -482,14 +480,13 @@
 OPERATION is the type of access, such as `oref' or `oset'.
 NEW-VALUE is the value that was being set into SLOT if OPERATION were
 a set type."
-  (if (or (eq slot-name 'object-name)
-	  (eq slot-name :object-name))
+  (if (memq slot-name '(object-name :object-name))
       (cond ((eq operation 'oset)
 	     (if (not (stringp new-value))
 		 (signal 'invalid-slot-type
 			 (list obj slot-name 'string new-value)))
-	     (object-set-name-string obj new-value))
-	    (t (object-name-string obj)))
+	     (eieio-object-set-name-string obj new-value))
+	    (t (eieio-object-name-string obj)))
     (call-next-method)))
 
 (provide 'eieio-base)

=== modified file 'lisp/emacs-lisp/eieio-custom.el'
--- lisp/emacs-lisp/eieio-custom.el	2013-01-01 09:11:05 +0000
+++ lisp/emacs-lisp/eieio-custom.el	2013-01-17 18:10:29 +0000
@@ -192,22 +192,22 @@
   (let* ((chil nil)
 	 (obj (widget-get widget :value))
 	 (master-group (widget-get widget :eieio-group))
-	 (cv (class-v (object-class-fast obj)))
-	 (slots (aref cv class-public-a))
-	 (flabel (aref cv class-public-custom-label))
-	 (fgroup (aref cv class-public-custom-group))
-	 (fdoc (aref cv class-public-doc))
-	 (fcust (aref cv class-public-custom)))
+	 (cv (class-v (eieio--object-class obj)))
+	 (slots (eieio--class-public-a cv))
+	 (flabel (eieio--class-public-custom-label cv))
+	 (fgroup (eieio--class-public-custom-group cv))
+	 (fdoc (eieio--class-public-doc cv))
+	 (fcust (eieio--class-public-custom cv)))
     ;; First line describes the object, but may not editable.
     (if (widget-get widget :eieio-show-name)
 	(setq chil (cons (widget-create-child-and-convert
 			  widget 'string :tag "Object "
 			  :sample-face 'bold
-			  (object-name-string obj))
+			  (eieio-object-name-string obj))
 			 chil)))
     ;; Display information about the group being shown
     (when master-group
-      (let ((groups (class-option (object-class-fast obj) :custom-groups)))
+      (let ((groups (class-option (eieio--object-class obj) :custom-groups)))
 	(widget-insert "Groups:")
 	(while groups
 	  (widget-insert "  ")
@@ -260,7 +260,7 @@
 			       (let ((s (symbol-name
 					 (or
 					  (class-slot-initarg
-					   (object-class-fast obj)
+					   (eieio--object-class obj)
 					   (car slots))
 					  (car slots)))))
 				 (capitalize
@@ -287,17 +287,17 @@
   "Get the value of WIDGET."
   (let* ((obj (widget-get widget :value))
 	 (master-group eieio-cog)
-	 (cv (class-v (object-class-fast obj)))
-	 (fgroup (aref cv class-public-custom-group))
+	 (cv (class-v (eieio--object-class obj)))
+	 (fgroup (eieio--class-public-custom-group cv))
 	 (wids (widget-get widget :children))
 	 (name (if (widget-get widget :eieio-show-name)
 		   (car (widget-apply (car wids) :value-inline))
 		 nil))
 	 (chil (if (widget-get widget :eieio-show-name)
 		   (nthcdr 1 wids) wids))
-	 (cv (class-v (object-class-fast obj)))
-	 (slots (aref cv class-public-a))
-	 (fcust (aref cv class-public-custom)))
+	 (cv (class-v (eieio--object-class obj)))
+	 (slots (eieio--class-public-a cv))
+	 (fcust (eieio--class-public-custom cv)))
     ;; If there are any prefix widgets, clear them.
     ;; -- None yet
     ;; Create a batch of initargs for each slot.
@@ -316,7 +316,7 @@
 	    fgroup (cdr fgroup)
 	    fcust (cdr fcust)))
     ;; Set any name updates on it.
-    (if name (aset obj object-name name))
+    (if name (setf (eieio--object-name obj) name))
     ;; This is the same object we had before.
     obj))
 
@@ -354,7 +354,7 @@
   (let* ((g (or group 'default)))
     (switch-to-buffer (get-buffer-create
 		       (concat "*CUSTOMIZE "
-			       (object-name obj) " "
+			       (eieio-object-name obj) " "
 			       (symbol-name g) "*")))
     (setq buffer-read-only nil)
     (kill-all-local-variables)
@@ -367,7 +367,7 @@
     ;; Add an apply reset option at the top of the buffer.
     (eieio-custom-object-apply-reset obj)
     (widget-insert "\n\n")
-    (widget-insert "Edit object " (object-name obj) "\n\n")
+    (widget-insert "Edit object " (eieio-object-name obj) "\n\n")
     ;; Create the widget editing the object.
     (make-local-variable 'eieio-wo)
     (setq eieio-wo (eieio-custom-widget-insert obj :eieio-group g))
@@ -452,7 +452,7 @@
 	    (vector (concat "Group " (symbol-name group))
 		    (list 'customize-object obj (list 'quote group))
 		    t))
-	  (class-option (object-class-fast obj) :custom-groups)))
+	  (class-option (eieio--object-class obj) :custom-groups)))
 
 (defvar eieio-read-custom-group-history nil
   "History for the custom group reader.")
@@ -460,7 +460,7 @@
 (defmethod eieio-read-customization-group ((obj eieio-default-superclass))
   "Do a completing read on the name of a customization group in OBJ.
 Return the symbol for the group, or nil"
-  (let ((g (class-option (object-class-fast obj) :custom-groups)))
+  (let ((g (class-option (eieio--object-class obj) :custom-groups)))
     (if (= (length g) 1)
 	(car g)
       ;; Make the association list

=== modified file 'lisp/emacs-lisp/eieio-datadebug.el'
--- lisp/emacs-lisp/eieio-datadebug.el	2013-01-01 09:11:05 +0000
+++ lisp/emacs-lisp/eieio-datadebug.el	2013-01-17 18:10:53 +0000
@@ -58,9 +58,9 @@
 	(end nil)
 	(str (object-print object))
 	(tip (format "Object %s\nClass: %S\nParent(s): %S\n%d slots"
-		     (object-name-string object)
-		     (object-class object)
-		     (class-parents (object-class object))
+		     (eieio-object-name-string object)
+		     (eieio-object-class object)
+		     (eieio-class-parents (eieio-object-class object))
 		     (length (object-slots object))
 		     ))
 	)
@@ -82,16 +82,16 @@
 (defmethod data-debug/eieio-insert-slots ((obj eieio-default-superclass)
 						prefix)
   "Insert the slots of OBJ into the current DDEBUG buffer."
-  (data-debug-insert-thing (object-name-string obj)
+  (data-debug-insert-thing (eieio-object-name-string obj)
 				prefix
 				"Name: ")
-  (let* ((cl (object-class obj))
+  (let* ((cl (eieio-object-class obj))
 	 (cv (class-v cl)))
     (data-debug-insert-thing (class-constructor cl)
 				  prefix
 				  "Class: ")
     ;; Loop over all the public slots
-    (let ((publa (aref cv class-public-a))
+    (let ((publa (eieio--class-public-a cv))
 	  )
       (while publa
 	(if (slot-boundp obj (car publa))
@@ -123,7 +123,7 @@
 ;;
 (defmethod data-debug-show ((obj eieio-default-superclass))
   "Run ddebug against any EIEIO object OBJ."
-  (data-debug-new-buffer (format "*%s DDEBUG*" (object-name obj)))
+  (data-debug-new-buffer (format "*%s DDEBUG*" (eieio-object-name obj)))
   (data-debug-insert-object-slots obj "]"))
 
 ;;; DEBUG FUNCTIONS

=== modified file 'lisp/emacs-lisp/eieio-opt.el'
--- lisp/emacs-lisp/eieio-opt.el	2013-01-01 09:11:05 +0000
+++ lisp/emacs-lisp/eieio-opt.el	2013-01-17 18:04:49 +0000
@@ -45,7 +45,7 @@
 						nil t)))
 		 nil))
   (if (not root-class) (setq root-class 'eieio-default-superclass))
-  (if (not (class-p root-class)) (signal 'wrong-type-argument (list 'class-p root-class)))
+  (eieio--check-type class-p root-class)
   (display-buffer (get-buffer-create "*EIEIO OBJECT BROWSE*") t)
   (with-current-buffer (get-buffer "*EIEIO OBJECT BROWSE*")
     (erase-buffer)
@@ -58,9 +58,9 @@
 Argument THIS-ROOT is the local root of the tree.
 Argument PREFIX is the character prefix to use.
 Argument CH-PREFIX is another character prefix to display."
-  (if (not (class-p (eval this-root))) (signal 'wrong-type-argument (list 'class-p this-root)))
+  (eieio--check-type class-p this-root)
   (let ((myname (symbol-name this-root))
-	(chl (aref (class-v this-root) class-children))
+	(chl (eieio--class-children (class-v this-root)))
 	(fprefix (concat ch-prefix "  +--"))
 	(mprefix (concat ch-prefix "  |  "))
 	(lprefix (concat ch-prefix "     ")))
@@ -99,7 +99,7 @@
       (princ "'"))
     (terpri)
     ;; Inheritance tree information
-    (let ((pl (class-parents class)))
+    (let ((pl (eieio-class-parents class)))
       (when pl
 	(princ " Inherits from ")
 	(while pl
@@ -107,7 +107,7 @@
 	  (setq pl (cdr pl))
 	  (if pl (princ ", ")))
 	(terpri)))
-    (let ((ch (class-children class)))
+    (let ((ch (eieio-class-children class)))
       (when ch
 	(princ " Children ")
 	(while ch
@@ -177,13 +177,13 @@
   "Describe the slots in CLASS.
 Outputs to the standard output."
   (let* ((cv (class-v class))
-	 (docs   (aref cv class-public-doc))
-	 (names  (aref cv class-public-a))
-	 (deflt  (aref cv class-public-d))
-	 (types  (aref cv class-public-type))
-	 (publp (aref cv class-public-printer))
+	 (docs   (eieio--class-public-doc cv))
+	 (names  (eieio--class-public-a cv))
+	 (deflt  (eieio--class-public-d cv))
+	 (types  (eieio--class-public-type cv))
+	 (publp (eieio--class-public-printer cv))
 	 (i      0)
-	 (prot   (aref cv class-protection))
+	 (prot   (eieio--class-protection cv))
 	 )
     (princ "Instance Allocated Slots:")
     (terpri)
@@ -213,11 +213,11 @@
 	    publp (cdr publp)
 	    prot (cdr prot)
 	    i (1+ i)))
-    (setq docs  (aref cv class-class-allocation-doc)
-	  names (aref cv class-class-allocation-a)
-	  types (aref cv class-class-allocation-type)
+    (setq docs  (eieio--class-class-allocation-doc cv)
+	  names (eieio--class-class-allocation-a cv)
+	  types (eieio--class-class-allocation-type cv)
 	  i     0
-	  prot  (aref cv class-class-allocation-protection))
+	  prot  (eieio--class-class-allocation-protection cv))
     (when names
 	(terpri)
 	(princ "Class Allocated Slots:"))
@@ -281,7 +281,7 @@
 	     (mapcar
 	      (lambda (c)
 		(append (list c) (eieio-build-class-list c)))
-	      (class-children-fast class)))
+	      (eieio-class-children-fast class)))
     (list class)))
 
 (defun eieio-build-class-alist (&optional class instantiable-only buildlist)
@@ -291,7 +291,7 @@
 are not abstract, otherwise allow all classes.
 Optional argument BUILDLIST is more list to attach and is used internally."
   (let* ((cc (or class eieio-default-superclass))
-	 (sublst (aref (class-v cc) class-children)))
+	 (sublst (eieio--class-children (class-v cc))))
     (unless (assoc (symbol-name cc) buildlist)
       (when (or (not instantiable-only) (not (class-abstract-p cc)))
 	(setq buildlist (cons (cons (symbol-name cc) 1) buildlist))))
@@ -335,8 +335,7 @@
   "Describe the generic function GENERIC.
 Also extracts information about all methods specific to this generic."
   (interactive (list (eieio-read-generic "Generic Method: ")))
-  (if (not (generic-p generic))
-      (signal 'wrong-type-argument '(generic-p generic)))
+  (eieio--check-type generic-p generic)
   (with-output-to-temp-buffer (help-buffer) ; "*Help*"
     (help-setup-xref (list #'eieio-describe-generic generic)
 		     (called-interactively-p 'interactive))
@@ -757,9 +756,8 @@
 
 (defun eieio-class-button (class depth)
   "Draw a speedbar button at the current point for CLASS at DEPTH."
-  (if (not (class-p class))
-      (signal 'wrong-type-argument (list 'class-p class)))
-  (let ((subclasses (aref (class-v class) class-children)))
+  (eieio--check-type class-p class)
+  (let ((subclasses (eieio--class-children (class-v class))))
     (if subclasses
 	(speedbar-make-tag-line 'angle ?+
 				'eieio-sb-expand
@@ -784,7 +782,7 @@
 	 (speedbar-with-writable
 	   (save-excursion
 	     (end-of-line) (forward-char 1)
-	     (let ((subclasses (aref (class-v class) class-children)))
+	     (let ((subclasses (eieio--class-children (class-v class))))
 	       (while subclasses
 		 (eieio-class-button (car subclasses) (1+ indent))
 		 (setq subclasses (cdr subclasses)))))))

=== modified file 'lisp/emacs-lisp/eieio-speedbar.el'
--- lisp/emacs-lisp/eieio-speedbar.el	2013-01-01 09:11:05 +0000
+++ lisp/emacs-lisp/eieio-speedbar.el	2013-01-17 18:04:21 +0000
@@ -198,7 +198,7 @@
 
 (defmethod eieio-speedbar-description (object)
   "Return a string describing OBJECT."
-  (object-name-string object))
+  (eieio-object-name-string object))
 
 (defmethod eieio-speedbar-derive-line-path (object)
   "Return the path which OBJECT has something to do with."
@@ -206,7 +206,7 @@
 
 (defmethod eieio-speedbar-object-buttonname (object)
   "Return a string to use as a speedbar button for OBJECT."
-  (object-name-string object))
+  (eieio-object-name-string object))
 
 (defmethod eieio-speedbar-make-tag-line (object depth)
   "Insert a tag line into speedbar at point for OBJECT.
@@ -324,7 +324,7 @@
 (defmethod eieio-speedbar-child-make-tag-lines ((object eieio-speedbar) depth)
   "Base method for creating tag lines for non-object children."
   (error "You must implement `eieio-speedbar-child-make-tag-lines' for %s"
-	 (object-name object)))
+	 (eieio-object-name object)))
 
 (defmethod eieio-speedbar-expand ((object eieio-speedbar) depth)
   "Expand OBJECT at indentation DEPTH.
@@ -365,7 +365,7 @@
 (defmethod eieio-speedbar-child-description ((obj eieio-speedbar))
   "Return a description for a child of OBJ which is not an object."
   (error "You must implement `eieio-speedbar-child-description' for %s"
-	 (object-name obj)))
+	 (eieio-object-name obj)))
 
 (defun eieio-speedbar-item-info ()
   "Display info for the current line when in EDE display mode."

=== modified file 'lisp/emacs-lisp/eieio.el'
--- lisp/emacs-lisp/eieio.el	2013-02-02 03:38:21 +0000
+++ lisp/emacs-lisp/eieio.el	2013-02-03 13:29:10 +0000
@@ -105,49 +105,68 @@
 
 ;; This is a bootstrap for eieio-default-superclass so it has a value
 ;; while it is being built itself.
-(defvar eieio-default-superclass nil)
+(defvar eieio-default-superclass nil))
 
-;; FIXME: The constants below should have an `eieio-' prefix added!!
-(defconst class-symbol 1 "Class's symbol (self-referencing.).")
-(defconst class-parent 2 "Class parent slot.")
-(defconst class-children 3 "Class children class slot.")
-(defconst class-symbol-obarray 4 "Obarray permitting fast access to variable position indexes.")
-;; @todo
-;; the word "public" here is leftovers from the very first version.
-;; Get rid of it!
-(defconst class-public-a 5 "Class attribute index.")
-(defconst class-public-d 6 "Class attribute defaults index.")
-(defconst class-public-doc 7 "Class documentation strings for attributes.")
-(defconst class-public-type 8 "Class type for a slot.")
-(defconst class-public-custom 9 "Class custom type for a slot.")
-(defconst class-public-custom-label 10 "Class custom group for a slot.")
-(defconst class-public-custom-group 11 "Class custom group for a slot.")
-(defconst class-public-printer 12 "Printer for a slot.")
-(defconst class-protection 13 "Class protection for a slot.")
-(defconst class-initarg-tuples 14 "Class initarg tuples list.")
-(defconst class-class-allocation-a 15 "Class allocated attributes.")
-(defconst class-class-allocation-doc 16 "Class allocated documentation.")
-(defconst class-class-allocation-type 17 "Class allocated value type.")
-(defconst class-class-allocation-custom 18 "Class allocated custom descriptor.")
-(defconst class-class-allocation-custom-label 19 "Class allocated custom descriptor.")
-(defconst class-class-allocation-custom-group 20 "Class allocated custom group.")
-(defconst class-class-allocation-printer 21 "Class allocated printer for a slot.")
-(defconst class-class-allocation-protection 22 "Class allocated protection list.")
-(defconst class-class-allocation-values 23 "Class allocated value vector.")
-(defconst class-default-object-cache 24
-  "Cache index of what a newly created object would look like.
+(defmacro eieio--define-field-accessors (prefix fields)
+  (declare (indent 1))
+  (let ((index 0)
+        (defs '()))
+    (dolist (field fields)
+      (let ((doc (if (listp field)
+                     (prog1 (cadr field) (setq field (car field))))))
+        (push `(defmacro ,(intern (format "eieio--%s-%s" prefix field)) (x)
+                 ,@(if doc (list (format (if (string-match "\n" doc)
+                                             "Return %s" "Return %s of a %s.")
+                                         doc prefix)))
+                 (list 'aref x ,index))
+              defs)
+        (setq index (1+ index))))
+    `(progn
+       ,@(nreverse defs)
+       (eval-and-compile
+         (defconst ,(intern (format "eieio--%s-num-slots" prefix)) ,index)))))
+
+(eieio--define-field-accessors class
+  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
+   (symbol "symbol (self-referencing)")
+   parent children
+   (symbol-obarray "obarray permitting fast access to variable position indexes")
+   ;; @todo
+   ;; the word "public" here is leftovers from the very first version.
+   ;; Get rid of it!
+   (public-a "class attribute index")
+   (public-d "class attribute defaults index")
+   (public-doc "class documentation strings for attributes")
+   (public-type "class type for a slot")
+   (public-custom "class custom type for a slot")
+   (public-custom-label "class custom group for a slot")
+   (public-custom-group "class custom group for a slot")
+   (public-printer "printer for a slot")
+   (protection "protection for a slot")
+   (initarg-tuples "initarg tuples list")
+   (class-allocation-a "class allocated attributes")
+   (class-allocation-doc "class allocated documentation")
+   (class-allocation-type "class allocated value type")
+   (class-allocation-custom "class allocated custom descriptor")
+   (class-allocation-custom-label "class allocated custom descriptor")
+   (class-allocation-custom-group "class allocated custom group")
+   (class-allocation-printer "class allocated printer for a slot")
+   (class-allocation-protection "class allocated protection list")
+   (class-allocation-values "class allocated value vector")
+   (default-object-cache "what a newly created object would look like.
 This will speed up instantiation time as only a `copy-sequence' will
 be needed, instead of looping over all the values and setting them
 from the default.")
-(defconst class-options 25
-  "Storage location of tagged class options.
-Stored outright without modifications or stripping.")
+   (options "storage location of tagged class options.
+Stored outright without modifications or stripping.")))
 
-(defconst class-num-slots 26
-  "Number of slots in the class definition object.")
+(eieio--define-field-accessors object
+  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
+   (class "class struct defining OBJ")
+   name))
 
-(defconst object-class 1 "Index in an object vector where the class is stored.")
-(defconst object-name 2 "Index in an object where the name is stored.")
+(eval-and-compile
+;; FIXME: The constants below should have an `eieio-' prefix added!!
 
 (defconst method-static 0 "Index into :static tag on a method.")
 (defconst method-before 1 "Index into :before tag on a method.")
@@ -188,13 +207,13 @@
   `(condition-case nil
        (let ((tobj ,obj))
 	 (and (eq (aref tobj 0) 'object)
-	      (class-p (aref tobj object-class))))
+	      (class-p (eieio--object-class tobj))))
      (error nil)))
 (defalias 'object-p 'eieio-object-p)
 
 (defmacro class-constructor (class)
   "Return the symbol representing the constructor of CLASS."
-  `(aref (class-v ,class) class-symbol))
+  `(eieio--class-symbol (class-v ,class)))
 
 (defmacro generic-p (method)
   "Return t if symbol METHOD is a generic function.
@@ -241,7 +260,7 @@
 (defmacro class-option (class option)
   "Return the value stored for CLASS' OPTION.
 Return nil if that option doesn't exist."
-  `(class-option-assoc (aref (class-v ,class) class-options) ',option))
+  `(class-option-assoc (eieio--class-options (class-v ,class)) ',option))
 
 (defmacro class-abstract-p (class)
   "Return non-nil if CLASS is abstract.
@@ -334,14 +353,14 @@
   ;; Assume we've already debugged inputs.
 
   (let* ((oldc (when (class-p cname) (class-v cname)))
-	 (newc (make-vector class-num-slots nil))
+	 (newc (make-vector eieio--class-num-slots nil))
 	 )
     (if oldc
 	nil ;; Do nothing if we already have this class.
 
       ;; Create the class in NEWC, but don't fill anything else in.
       (aset newc 0 'defclass)
-      (aset newc class-symbol cname)
+      (setf (eieio--class-symbol newc) cname)
 
       (let ((clear-parent nil))
 	;; No parents?
@@ -371,12 +390,12 @@
 		)
 
 	    ;; We have a parent, save the child in there.
-	    (when (not (member cname (aref (class-v SC) class-children)))
-	      (aset (class-v SC) class-children
-		    (cons cname (aref (class-v SC) class-children)))))
+	    (when (not (member cname (eieio--class-children (class-v SC))))
+	      (setf (eieio--class-children (class-v SC))
+		    (cons cname (eieio--class-children (class-v SC))))))
 
 	  ;; save parent in child
-	  (aset newc class-parent (cons SC (aref newc class-parent)))
+	  (setf (eieio--class-parent newc) (cons SC (eieio--class-parent newc)))
 	  )
 
 	;; turn this into a usable self-pointing symbol
@@ -389,7 +408,7 @@
 	(put cname 'eieio-class-definition newc)
 
 	;; Clear the parent
-	(if clear-parent (aset newc class-parent nil))
+	(if clear-parent (setf (eieio--class-parent newc) nil))
 
 	;; Create an autoload on top of our constructor function.
 	(autoload cname filename doc nil nil)
@@ -404,6 +423,15 @@
   (when (eq (car-safe (symbol-function cname)) 'autoload)
     (load-library (car (cdr (symbol-function cname))))))
 
+(defmacro eieio--check-type (type obj)
+  (unless (symbolp obj)
+    (error "eieio--check-type wants OBJ to be a variable"))
+  `(if (not ,(cond
+              ((eq 'or (car-safe type))
+               `(or ,@(mapcar (lambda (type) `(,type ,obj)) (cdr type))))
+              (t `(,type ,obj))))
+       (signal 'wrong-type-argument (list ',type ,obj))))
+
 (defun eieio-defclass (cname superclasses slots options-and-doc)
   ;; FIXME: Most of this should be moved to the `defclass' macro.
   "Define CNAME as a new subclass of SUPERCLASSES.
@@ -416,18 +444,17 @@
   (run-hooks 'eieio-hook)
   (setq eieio-hook nil)
 
-  (if (not (listp superclasses))
-      (signal 'wrong-type-argument '(listp superclasses)))
+  (eieio--check-type listp superclasses)
 
   (let* ((pname superclasses)
-	 (newc (make-vector class-num-slots nil))
+	 (newc (make-vector eieio--class-num-slots nil))
 	 (oldc (when (class-p cname) (class-v cname)))
 	 (groups nil) ;; list of groups id'd from slots
 	 (options nil)
 	 (clearparent nil))
 
     (aset newc 0 'defclass)
-    (aset newc class-symbol cname)
+    (setf (eieio--class-symbol newc) cname)
 
     ;; If this class already existed, and we are updating its structure,
     ;; make sure we keep the old child list.  This can cause bugs, but
@@ -435,13 +462,13 @@
     ;; method table breakage, particularly when the users is only
     ;; byte compiling an EIEIO file.
     (if oldc
-	(aset newc class-children (aref oldc class-children))
+	(setf (eieio--class-children newc) (eieio--class-children oldc))
       ;; If the old class did not exist, but did exist in the autoload map, then adopt those children.
       ;; This is like the above, but deals with autoloads nicely.
       (let ((sym (intern-soft (symbol-name cname) eieio-defclass-autoload-map)))
 	(when sym
 	  (condition-case nil
-	      (aset newc class-children (symbol-value sym))
+	      (setf (eieio--class-children newc) (symbol-value sym))
 	    (error nil))
 	  (unintern (symbol-name cname) eieio-defclass-autoload-map)
 	  ))
@@ -469,30 +496,30 @@
 		    (error "Given parent class %s is not a class" (car pname))
 		  ;; good parent class...
 		  ;; save new child in parent
-		  (when (not (member cname (aref (class-v (car pname)) class-children)))
-		    (aset (class-v (car pname)) class-children
-			  (cons cname (aref (class-v (car pname)) class-children))))
+		  (when (not (member cname (eieio--class-children (class-v (car pname)))))
+		    (setf (eieio--class-children (class-v (car pname)))
+			  (cons cname (eieio--class-children (class-v (car pname))))))
 		  ;; Get custom groups, and store them into our local copy.
 		  (mapc (lambda (g) (add-to-list 'groups g))
 			(class-option (car pname) :custom-groups))
 		  ;; save parent in child
-		  (aset newc class-parent (cons (car pname) (aref newc class-parent))))
+		  (setf (eieio--class-parent newc) (cons (car pname) (eieio--class-parent newc))))
 	      (error "Invalid parent class %s" pname))
 	    (setq pname (cdr pname)))
 	  ;; Reverse the list of our parents so that they are prioritized in
 	  ;; the same order as specified in the code.
-	  (aset newc class-parent (nreverse (aref newc class-parent))) )
+	  (setf (eieio--class-parent newc) (nreverse (eieio--class-parent newc))) )
       ;; If there is nothing to loop over, then inherit from the
       ;; default superclass.
       (unless (eq cname 'eieio-default-superclass)
 	;; adopt the default parent here, but clear it later...
 	(setq clearparent t)
 	;; save new child in parent
-	(if (not (member cname (aref (class-v 'eieio-default-superclass) class-children)))
-	    (aset (class-v 'eieio-default-superclass) class-children
-		  (cons cname (aref (class-v 'eieio-default-superclass) class-children))))
+	(if (not (member cname (eieio--class-children (class-v 'eieio-default-superclass))))
+	    (setf (eieio--class-children (class-v 'eieio-default-superclass))
+		  (cons cname (eieio--class-children (class-v 'eieio-default-superclass)))))
 	;; save parent in child
-	(aset newc class-parent (list eieio-default-superclass))))
+	(setf (eieio--class-parent newc) (list eieio-default-superclass))))
 
     ;; turn this into a usable self-pointing symbol
     (set cname cname)
@@ -714,26 +741,26 @@
 
     ;; Now that everything has been loaded up, all our lists are backwards!
     ;; Fix that up now.
-    (aset newc class-public-a (nreverse (aref newc class-public-a)))
-    (aset newc class-public-d (nreverse (aref newc class-public-d)))
-    (aset newc class-public-doc (nreverse (aref newc class-public-doc)))
-    (aset newc class-public-type
-	  (apply 'vector (nreverse (aref newc class-public-type))))
-    (aset newc class-public-custom (nreverse (aref newc class-public-custom)))
-    (aset newc class-public-custom-label (nreverse (aref newc class-public-custom-label)))
-    (aset newc class-public-custom-group (nreverse (aref newc class-public-custom-group)))
-    (aset newc class-public-printer (nreverse (aref newc class-public-printer)))
-    (aset newc class-protection (nreverse (aref newc class-protection)))
-    (aset newc class-initarg-tuples (nreverse (aref newc class-initarg-tuples)))
+    (setf (eieio--class-public-a newc) (nreverse (eieio--class-public-a newc)))
+    (setf (eieio--class-public-d newc) (nreverse (eieio--class-public-d newc)))
+    (setf (eieio--class-public-doc newc) (nreverse (eieio--class-public-doc newc)))
+    (setf (eieio--class-public-type newc)
+	  (apply 'vector (nreverse (eieio--class-public-type newc))))
+    (setf (eieio--class-public-custom newc) (nreverse (eieio--class-public-custom newc)))
+    (setf (eieio--class-public-custom-label newc) (nreverse (eieio--class-public-custom-label newc)))
+    (setf (eieio--class-public-custom-group newc) (nreverse (eieio--class-public-custom-group newc)))
+    (setf (eieio--class-public-printer newc) (nreverse (eieio--class-public-printer newc)))
+    (setf (eieio--class-protection newc) (nreverse (eieio--class-protection newc)))
+    (setf (eieio--class-initarg-tuples newc) (nreverse (eieio--class-initarg-tuples newc)))
 
     ;; The storage for class-class-allocation-type needs to be turned into
     ;; a vector now.
-    (aset newc class-class-allocation-type
-	  (apply 'vector (aref newc class-class-allocation-type)))
+    (setf (eieio--class-class-allocation-type newc)
+	  (apply 'vector (eieio--class-class-allocation-type newc)))
 
     ;; Also, take class allocated values, and vectorize them for speed.
-    (aset newc class-class-allocation-values
-	  (apply 'vector (aref newc class-class-allocation-values)))
+    (setf (eieio--class-class-allocation-values newc)
+	  (apply 'vector (eieio--class-class-allocation-values newc)))
 
     ;; Attach slot symbols into an obarray, and store the index of
     ;; this slot as the variable slot in this new symbol.  We need to
@@ -741,8 +768,8 @@
     ;; prime number length, and we also need to make our vector small
     ;; to save space, and also optimal for the number of items we have.
     (let* ((cnt 0)
-	   (pubsyms (aref newc class-public-a))
-	   (prots (aref newc class-protection))
+	   (pubsyms (eieio--class-public-a newc))
+	   (prots (eieio--class-protection newc))
 	   (l (length pubsyms))
 	   (vl (let ((primes '( 3 5 7 11 13 17 19 23 29 31 37 41 43 47
 				  53 59 61 67 71 73 79 83 89 97 101 )))
@@ -758,7 +785,7 @@
 	(if (car prots) (put newsym 'protection (car prots)))
 	(setq pubsyms (cdr pubsyms)
 	      prots (cdr prots)))
-      (aset newc class-symbol-obarray oa)
+      (setf (eieio--class-symbol-obarray newc) oa)
       )
 
     ;; Create the constructor function
@@ -790,7 +817,7 @@
 		   buffer-file-name))
 	  loc)
       (when fname
-	(when (string-match "\\.elc$" fname)
+	(when (string-match "\\.elc\\'" fname)
 	  (setq fname (substring fname 0 (1- (length fname)))))
 	(put cname 'class-location fname)))
 
@@ -802,23 +829,23 @@
 	(setq options (cons :custom-groups (cons g options)))))
 
     ;; Set up the options we have collected.
-    (aset newc class-options options)
+    (setf (eieio--class-options newc) options)
 
     ;; if this is a superclass, clear out parent (which was set to the
     ;; default superclass eieio-default-superclass)
-    (if clearparent (aset newc class-parent nil))
+    (if clearparent (setf (eieio--class-parent newc) nil))
 
     ;; Create the cached default object.
-    (let ((cache (make-vector (+ (length (aref newc class-public-a))
-				 3) nil)))
+    (let ((cache (make-vector (+ (length (eieio--class-public-a newc)) 3)
+                              nil)))
       (aset cache 0 'object)
-      (aset cache object-class cname)
-      (aset cache object-name 'default-cache-object)
+      (setf (eieio--object-class cache) cname)
+      (setf (eieio--object-name cache) 'default-cache-object)
       (let ((eieio-skip-typecheck t))
 	;; All type-checking has been done to our satisfaction
 	;; before this call.  Don't waste our time in this call..
 	(eieio-set-defaults cache t))
-      (aset newc class-default-object-cache cache))
+      (setf (eieio--class-default-object-cache newc) cache))
 
     ;; Return our new class object
     ;; newc
@@ -855,7 +882,7 @@
 
   ;; To prevent override information w/out specification of storage,
   ;; we need to do this little hack.
-  (if (member a (aref newc class-class-allocation-a)) (setq alloc ':class))
+  (if (member a (eieio--class-class-allocation-a newc)) (setq alloc ':class))
 
   (if (or (not alloc) (and (symbolp alloc) (eq alloc ':instance)))
       ;; In this case, we modify the INSTANCE version of a given slot.
@@ -863,31 +890,31 @@
       (progn
 
 	;; Only add this element if it is so-far unique
-	(if (not (member a (aref newc class-public-a)))
+	(if (not (member a (eieio--class-public-a newc)))
 	    (progn
 	      (eieio-perform-slot-validation-for-default a type d skipnil)
-	      (aset newc class-public-a (cons a (aref newc class-public-a)))
-	      (aset newc class-public-d (cons d (aref newc class-public-d)))
-	      (aset newc class-public-doc (cons doc (aref newc class-public-doc)))
-	      (aset newc class-public-type (cons type (aref newc class-public-type)))
-	      (aset newc class-public-custom (cons cust (aref newc class-public-custom)))
-	      (aset newc class-public-custom-label (cons label (aref newc class-public-custom-label)))
-	      (aset newc class-public-custom-group (cons custg (aref newc class-public-custom-group)))
-	      (aset newc class-public-printer (cons print (aref newc class-public-printer)))
-	      (aset newc class-protection (cons prot (aref newc class-protection)))
-	      (aset newc class-initarg-tuples (cons (cons init a) (aref newc class-initarg-tuples)))
+	      (setf (eieio--class-public-a newc) (cons a (eieio--class-public-a newc)))
+	      (setf (eieio--class-public-d newc) (cons d (eieio--class-public-d newc)))
+	      (setf (eieio--class-public-doc newc) (cons doc (eieio--class-public-doc newc)))
+	      (setf (eieio--class-public-type newc) (cons type (eieio--class-public-type newc)))
+	      (setf (eieio--class-public-custom newc) (cons cust (eieio--class-public-custom newc)))
+	      (setf (eieio--class-public-custom-label newc) (cons label (eieio--class-public-custom-label newc)))
+	      (setf (eieio--class-public-custom-group newc) (cons custg (eieio--class-public-custom-group newc)))
+	      (setf (eieio--class-public-printer newc) (cons print (eieio--class-public-printer newc)))
+	      (setf (eieio--class-protection newc) (cons prot (eieio--class-protection newc)))
+	      (setf (eieio--class-initarg-tuples newc) (cons (cons init a) (eieio--class-initarg-tuples newc)))
 	      )
 	  ;; When defaultoverride is true, we are usually adding new local
 	  ;; attributes which must override the default value of any slot
 	  ;; passed in by one of the parent classes.
 	  (when defaultoverride
 	    ;; There is a match, and we must override the old value.
-	    (let* ((ca (aref newc class-public-a))
+	    (let* ((ca (eieio--class-public-a newc))
 		   (np (member a ca))
 		   (num (- (length ca) (length np)))
-		   (dp (if np (nthcdr num (aref newc class-public-d))
+		   (dp (if np (nthcdr num (eieio--class-public-d newc))
 			 nil))
-		   (tp (if np (nth num (aref newc class-public-type))))
+		   (tp (if np (nth num (eieio--class-public-type newc))))
 		   )
 	      (if (not np)
 		  (error "EIEIO internal error overriding default value for %s"
@@ -904,7 +931,7 @@
 		  (setcar dp d))
 		;; If we have a new initarg, check for it.
 		(when init
-		  (let* ((inits (aref newc class-initarg-tuples))
+		  (let* ((inits (eieio--class-initarg-tuples newc))
 			 (inita (rassq a inits)))
 		    ;; Replace the CAR of the associate INITA.
 		    ;;(message "Initarg: %S replace %s" inita init)
@@ -920,7 +947,7 @@
 		;; EML - We used to have (if prot... here,
 		;;       but a prot of 'nil means public.
 		;;
-		(let ((super-prot (nth num (aref newc class-protection)))
+		(let ((super-prot (nth num (eieio--class-protection newc)))
 		      )
 		  (if (not (eq prot super-prot))
 		      (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
@@ -932,7 +959,7 @@
 		;; groups and new ones.
 		(when custg
 		  (let* ((groups
-			  (nthcdr num (aref newc class-public-custom-group)))
+			  (nthcdr num (eieio--class-public-custom-group newc)))
 			 (list1 (car groups))
 			 (list2 (if (listp custg) custg (list custg))))
 		    (if (< (length list1) (length list2))
@@ -947,20 +974,20 @@
 		;;  set, simply replaces the old one.
 		(when cust
 		  ;; (message "Custom type redefined to %s" cust)
-		  (setcar (nthcdr num (aref newc class-public-custom)) cust))
+		  (setcar (nthcdr num (eieio--class-public-custom newc)) cust))
 
 		;; If a new label is specified, it simply replaces
 		;; the old one.
 		(when label
 		  ;; (message "Custom label redefined to %s" label)
-		  (setcar (nthcdr num (aref newc class-public-custom-label)) label))
+		  (setcar (nthcdr num (eieio--class-public-custom-label newc)) label))
 		;;  End PLN
 
 		;; PLN Sat Jun 30 17:24:42 2007 : when a new
 		;; doc is specified, simply replaces the old one.
 		(when doc
 		  ;;(message "Documentation redefined to %s" doc)
-		  (setcar (nthcdr num (aref newc class-public-doc))
+		  (setcar (nthcdr num (eieio--class-public-doc newc))
 			  doc))
 		;; End PLN
 
@@ -968,38 +995,38 @@
 		;; the old one.
 		(when print
 		  ;; (message "printer redefined to %s" print)
-		  (setcar (nthcdr num (aref newc class-public-printer)) print))
+		  (setcar (nthcdr num (eieio--class-public-printer newc)) print))
 
 		)))
 	  ))
 
     ;; CLASS ALLOCATED SLOTS
     (let ((value (eieio-default-eval-maybe d)))
-      (if (not (member a (aref newc class-class-allocation-a)))
+      (if (not (member a (eieio--class-class-allocation-a newc)))
 	  (progn
 	    (eieio-perform-slot-validation-for-default a type value skipnil)
 	    ;; Here we have found a :class version of a slot.  This
 	    ;; requires a very different approach.
-	    (aset newc class-class-allocation-a (cons a (aref newc class-class-allocation-a)))
-	    (aset newc class-class-allocation-doc (cons doc (aref newc class-class-allocation-doc)))
-	    (aset newc class-class-allocation-type (cons type (aref newc class-class-allocation-type)))
-	    (aset newc class-class-allocation-custom (cons cust (aref newc class-class-allocation-custom)))
-	    (aset newc class-class-allocation-custom-label (cons label (aref newc class-class-allocation-custom-label)))
-	    (aset newc class-class-allocation-custom-group (cons custg (aref newc class-class-allocation-custom-group)))
-	    (aset newc class-class-allocation-protection (cons prot (aref newc class-class-allocation-protection)))
+	    (setf (eieio--class-class-allocation-a newc) (cons a (eieio--class-class-allocation-a newc)))
+	    (setf (eieio--class-class-allocation-doc newc) (cons doc (eieio--class-class-allocation-doc newc)))
+	    (setf (eieio--class-class-allocation-type newc) (cons type (eieio--class-class-allocation-type newc)))
+	    (setf (eieio--class-class-allocation-custom newc) (cons cust (eieio--class-class-allocation-custom newc)))
+	    (setf (eieio--class-class-allocation-custom-label newc) (cons label (eieio--class-class-allocation-custom-label newc)))
+	    (setf (eieio--class-class-allocation-custom-group newc) (cons custg (eieio--class-class-allocation-custom-group newc)))
+	    (setf (eieio--class-class-allocation-protection newc) (cons prot (eieio--class-class-allocation-protection newc)))
 	    ;; Default value is stored in the 'values section, since new objects
 	    ;; can't initialize from this element.
-	    (aset newc class-class-allocation-values (cons value (aref newc class-class-allocation-values))))
+	    (setf (eieio--class-class-allocation-values newc) (cons value (eieio--class-class-allocation-values newc))))
 	(when defaultoverride
 	  ;; There is a match, and we must override the old value.
-	  (let* ((ca (aref newc class-class-allocation-a))
+	  (let* ((ca (eieio--class-class-allocation-a newc))
 		 (np (member a ca))
 		 (num (- (length ca) (length np)))
 		 (dp (if np
 			 (nthcdr num
-				 (aref newc class-class-allocation-values))
+				 (eieio--class-class-allocation-values newc))
 		       nil))
-		 (tp (if np (nth num (aref newc class-class-allocation-type))
+		 (tp (if np (nth num (eieio--class-class-allocation-type newc))
 		       nil)))
 	    (if (not np)
 		(error "EIEIO internal error overriding default value for %s"
@@ -1023,7 +1050,7 @@
 	    ;; I wonder if a more flexible schedule might be
 	    ;; implemented.
 	    (let ((super-prot
-		   (car (nthcdr num (aref newc class-class-allocation-protection)))))
+		   (car (nthcdr num (eieio--class-class-allocation-protection newc)))))
 	      (if (not (eq prot super-prot))
 		  (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
 			 prot super-prot a)))
@@ -1031,7 +1058,7 @@
 	    ;; and new ones.
 	    (when custg
 	      (let* ((groups
-		      (nthcdr num (aref newc class-class-allocation-custom-group)))
+		      (nthcdr num (eieio--class-class-allocation-custom-group newc)))
 		     (list1 (car groups))
 		     (list2 (if (listp custg) custg (list custg))))
 		(if (< (length list1) (length list2))
@@ -1045,7 +1072,7 @@
 	    ;; doc is specified, simply replaces the old one.
 	    (when doc
 	      ;;(message "Documentation redefined to %s" doc)
-	      (setcar (nthcdr num (aref newc class-class-allocation-doc))
+	      (setcar (nthcdr num (eieio--class-class-allocation-doc newc))
 		      doc))
 	    ;; End PLN
 
@@ -1053,7 +1080,7 @@
 	    ;; the old one.
 	    (when print
 	      ;; (message "printer redefined to %s" print)
-	      (setcar (nthcdr num (aref newc class-class-allocation-printer)) print))
+	      (setcar (nthcdr num (eieio--class-class-allocation-printer newc)) print))
 
 	    ))
 	))
@@ -1063,22 +1090,22 @@
   "Copy into NEWC the slots of PARENTS.
 Follow the rules of not overwriting early parents when applying to
 the new child class."
-  (let ((ps (aref newc class-parent))
-	(sn (class-option-assoc (aref newc class-options)
+  (let ((ps (eieio--class-parent newc))
+	(sn (class-option-assoc (eieio--class-options newc)
 				':allow-nil-initform)))
     (while ps
       ;; First, duplicate all the slots of the parent.
       (let ((pcv (class-v (car ps))))
-	(let ((pa (aref pcv class-public-a))
-	      (pd (aref pcv class-public-d))
-	      (pdoc (aref pcv class-public-doc))
-	      (ptype (aref pcv class-public-type))
-	      (pcust (aref pcv class-public-custom))
-	      (plabel (aref pcv class-public-custom-label))
-	      (pcustg (aref pcv class-public-custom-group))
-	      (printer (aref pcv class-public-printer))
-	      (pprot (aref pcv class-protection))
-	      (pinit (aref pcv class-initarg-tuples))
+	(let ((pa (eieio--class-public-a pcv))
+	      (pd (eieio--class-public-d pcv))
+	      (pdoc (eieio--class-public-doc pcv))
+	      (ptype (eieio--class-public-type pcv))
+	      (pcust (eieio--class-public-custom pcv))
+	      (plabel (eieio--class-public-custom-label pcv))
+	      (pcustg (eieio--class-public-custom-group pcv))
+	      (printer (eieio--class-public-printer pcv))
+	      (pprot (eieio--class-protection pcv))
+	      (pinit (eieio--class-initarg-tuples pcv))
 	      (i 0))
 	  (while pa
 	    (eieio-add-new-slot newc
@@ -1099,15 +1126,15 @@
 		  pinit (cdr pinit))
 	    )) ;; while/let
 	;; Now duplicate all the class alloc slots.
-	(let ((pa (aref pcv class-class-allocation-a))
-	      (pdoc (aref pcv class-class-allocation-doc))
-	      (ptype (aref pcv class-class-allocation-type))
-	      (pcust (aref pcv class-class-allocation-custom))
-	      (plabel (aref pcv class-class-allocation-custom-label))
-	      (pcustg (aref pcv class-class-allocation-custom-group))
-	      (printer (aref pcv class-class-allocation-printer))
-	      (pprot (aref pcv class-class-allocation-protection))
-	      (pval (aref pcv class-class-allocation-values))
+	(let ((pa (eieio--class-class-allocation-a pcv))
+	      (pdoc (eieio--class-class-allocation-doc pcv))
+	      (ptype (eieio--class-class-allocation-type pcv))
+	      (pcust (eieio--class-class-allocation-custom pcv))
+	      (plabel (eieio--class-class-allocation-custom-label pcv))
+	      (pcustg (eieio--class-class-allocation-custom-group pcv))
+	      (printer (eieio--class-class-allocation-printer pcv))
+	      (pprot (eieio--class-class-allocation-protection pcv))
+	      (pval (eieio--class-class-allocation-values pcv))
 	      (i 0))
 	  (while pa
 	    (eieio-add-new-slot newc
@@ -1252,7 +1279,7 @@
 	  ;; We do have an object.  Make sure it is the right type.
 	  (if ,(if (eq class eieio-default-superclass)
 		   nil  ; default superclass means just an obj.  Already asked.
-		 `(not (child-of-class-p (aref (car local-args) object-class)
+		 `(not (child-of-class-p (eieio--object-class (car local-args))
 					 ',class)))
 
 	      ;; If not the right kind of object, call no applicable
@@ -1335,27 +1362,20 @@
 (defun eieio--defmethod (method kind argclass code)
   "Work part of the `defmethod' macro defining METHOD with ARGS."
   (let ((key
-         ;; find optional keys
-         (cond ((or (eq ':BEFORE kind)
-                    (eq ':before kind))
-                method-before)
-               ((or (eq ':AFTER kind)
-                    (eq ':after kind))
-                method-after)
-               ((or (eq ':PRIMARY kind)
-                    (eq ':primary kind))
-                method-primary)
-               ((or (eq ':STATIC kind)
-                    (eq ':static kind))
-                method-static)
-               ;; Primary key
-               (t method-primary))))
+         ;; Find optional keys.
+         (cond ((memq kind '(:BEFORE :before)) method-before)
+               ((memq kind '(:AFTER :after)) method-after)
+               ((memq kind '(:STATIC :static)) method-static)
+               ((memq kind '(:PRIMARY :primary nil)) method-primary)
+               ;; Primary key.
+               ;; (t method-primary)
+               (t (error "Unknown method kind %S" kind)))))
     ;; Make sure there is a generic (when called from defclass).
     (eieio--defalias
      method (eieio--defgeneric-init-form
              method (or (documentation code)
                         (format "Generically created method `%s'." method))))
-    ;; create symbol for property to bind to.  If the first arg is of
+    ;; Create symbol for property to bind to.  If the first arg is of
     ;; the form (varname vartype) and `vartype' is a class, then
     ;; that class will be the type symbol.  If not, then it will fall
     ;; under the type `primary' which is a non-specific calling of the
@@ -1364,11 +1384,9 @@
         (if (not (class-p argclass))
             (error "Unknown class type %s in method parameters"
                    argclass))
-      (if (= key -1)
-	  (signal 'wrong-type-argument (list :static 'non-class-arg)))
-      ;; generics are higher
+      ;; Generics are higher.
       (setq key (eieio-specialized-key-to-generic-key key)))
-    ;; Put this lambda into the symbol so we can find it
+    ;; Put this lambda into the symbol so we can find it.
     (eieiomt-add method code key argclass)
     )
 
@@ -1449,7 +1467,7 @@
       nil
     ;; Trim off object IDX junk added in for the object index.
     (setq slot-idx (- slot-idx 3))
-    (let ((st (aref (aref (class-v class) class-public-type) slot-idx)))
+    (let ((st (aref (eieio--class-public-type (class-v class)) slot-idx)))
       (if (not (eieio-perform-slot-validation st value))
 	  (signal 'invalid-slot-type (list class slot st value))))))
 
@@ -1460,7 +1478,7 @@
 an error."
   (if eieio-skip-typecheck
       nil
-    (let ((st (aref (aref (class-v class) class-class-allocation-type)
+    (let ((st (aref (eieio--class-class-allocation-type (class-v class))
 		    slot-idx)))
       (if (not (eieio-perform-slot-validation st value))
 	  (signal 'invalid-slot-type (list class slot st value))))))
@@ -1471,7 +1489,7 @@
 slot.  If the slot is ok, return VALUE.
 Argument FN is the function calling this verifier."
   (if (and (eq value eieio-unbound) (not eieio-skip-typecheck))
-      (slot-unbound instance (object-class instance) slotname fn)
+      (slot-unbound instance (eieio-object-class instance) slotname fn)
     value))
 
 ;;; Get/Set slots in an object.
@@ -1484,27 +1502,24 @@
 
 (defun eieio-oref (obj slot)
   "Return the value in OBJ at SLOT in the object vector."
-  (if (not (or (eieio-object-p obj) (class-p obj)))
-      (signal 'wrong-type-argument (list '(or eieio-object-p class-p) obj)))
-  (if (not (symbolp slot))
-      (signal 'wrong-type-argument (list 'symbolp slot)))
+  (eieio--check-type (or eieio-object-p class-p) obj)
+  (eieio--check-type symbolp slot)
   (if (class-p obj) (eieio-class-un-autoload obj))
-  (let* ((class (if (class-p obj) obj (aref obj object-class)))
+  (let* ((class (if (class-p obj) obj (eieio--object-class obj)))
 	 (c (eieio-slot-name-index class obj slot)))
     (if (not c)
 	;; It might be missing because it is a :class allocated slot.
 	;; Let's check that info out.
 	(if (setq c (eieio-class-slot-name-index class slot))
 	    ;; Oref that slot.
-	    (aref (aref (class-v class) class-class-allocation-values) c)
+	    (aref (eieio--class-class-allocation-values (class-v class)) c)
 	  ;; The slot-missing method is a cool way of allowing an object author
 	  ;; to intercept missing slot definitions.  Since it is also the LAST
 	  ;; thing called in this fn, its return value would be retrieved.
 	  (slot-missing obj slot 'oref)
-	  ;;(signal 'invalid-slot-name (list (object-name obj) slot))
+	  ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
 	  )
-      (if (not (eieio-object-p obj))
-	  (signal 'wrong-type-argument (list 'eieio-object-p obj)))
+      (eieio--check-type eieio-object-p obj)
       (eieio-barf-if-slot-unbound (aref obj c) obj slot 'oref))))
 
 (defalias 'slot-value 'eieio-oref)
@@ -1520,9 +1535,9 @@
 (defun eieio-oref-default (obj slot)
   "Do the work for the macro `oref-default' with similar parameters.
 Fills in OBJ's SLOT with its default value."
-  (if (not (or (eieio-object-p obj) (class-p obj))) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (if (not (symbolp slot)) (signal 'wrong-type-argument (list 'symbolp slot)))
-  (let* ((cl (if (eieio-object-p obj) (aref obj object-class) obj))
+  (eieio--check-type (or eieio-object-p class-p) obj)
+  (eieio--check-type symbolp slot)
+  (let* ((cl (if (eieio-object-p obj) (eieio--object-class obj) obj))
 	 (c (eieio-slot-name-index cl obj slot)))
     (if (not c)
 	;; It might be missing because it is a :class allocated slot.
@@ -1530,13 +1545,13 @@
 	(if (setq c
 		  (eieio-class-slot-name-index cl slot))
 	    ;; Oref that slot.
-	    (aref (aref (class-v cl) class-class-allocation-values)
+	    (aref (eieio--class-class-allocation-values (class-v cl))
 		  c)
 	  (slot-missing obj slot 'oref-default)
 	  ;;(signal 'invalid-slot-name (list (class-name cl) slot))
 	  )
       (eieio-barf-if-slot-unbound
-       (let ((val (nth (- c 3) (aref (class-v cl) class-public-d))))
+       (let ((val (nth (- c 3) (eieio--class-public-d (class-v cl)))))
 	 (eieio-default-eval-maybe val))
        obj cl 'oref-default))))
 
@@ -1590,62 +1605,78 @@
 ;;; Simple generators, and query functions.  None of these would do
 ;;  well embedded into an object.
 ;;
-(defmacro object-class-fast (obj) "Return the class struct defining OBJ with no check."
-  `(aref ,obj object-class))
+(define-obsolete-function-alias
+  'object-class-fast #'eieio--object-class "future")
 
-(defun class-name (class) "Return a Lisp like symbol name for CLASS."
-  (if (not (class-p class)) (signal 'wrong-type-argument (list 'class-p class)))
+(defun eieio-class-name (class) "Return a Lisp like symbol name for CLASS."
+  (eieio--check-type class-p class)
   ;; I think this is supposed to return a symbol, but to me CLASS is a symbol,
   ;; and I wanted a string.  Arg!
   (format "#<class %s>" (symbol-name class)))
+(define-obsolete-function-alias 'class-name #'eieio-class-name "future")
 
-(defun object-name (obj &optional extra)
+(defun eieio-object-name (obj &optional extra)
   "Return a Lisp like symbol string for object OBJ.
 If EXTRA, include that in the string returned to represent the symbol."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (format "#<%s %s%s>" (symbol-name (object-class-fast obj))
-	  (aref obj object-name) (or extra "")))
-
-(defun object-name-string (obj) "Return a string which is OBJ's name."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (aref obj object-name))
-
-(defun object-set-name-string (obj name) "Set the string which is OBJ's NAME."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (if (not (stringp name)) (signal 'wrong-type-argument (list 'stringp name)))
-  (aset obj object-name name))
-
-(defun object-class (obj) "Return the class struct defining OBJ."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (object-class-fast obj))
-(defalias 'class-of 'object-class)
-
-(defun object-class-name (obj) "Return a Lisp like symbol name for OBJ's class."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
-  (class-name (object-class-fast obj)))
-
-(defmacro class-parents-fast (class) "Return parent classes to CLASS with no check."
-  `(aref (class-v ,class) class-parent))
+  (eieio--check-type eieio-object-p obj)
+  (format "#<%s %s%s>" (symbol-name (eieio--object-class obj))
+	  (eieio--object-name obj) (or extra "")))
+(define-obsolete-function-alias 'object-name #'eieio-object-name "future")
+
+(defun eieio-object-name-string (obj) "Return a string which is OBJ's name."
+  (eieio--check-type eieio-object-p obj)
+  (eieio--object-name obj))
+(define-obsolete-function-alias
+  'object-name-string #'eieio-object-name-string "future")
+
+(defun eieio-object-set-name-string (obj name)
+  "Set the string which is OBJ's NAME."
+  (eieio--check-type eieio-object-p obj)
+  (eieio--check-type stringp name)
+  (setf (eieio--object-name obj) name))
+(define-obsolete-function-alias
+  'object-set-name-string 'eieio-object-set-name-string "future")
+
+(defun eieio-object-class (obj) "Return the class struct defining OBJ."
+  (eieio--check-type eieio-object-p obj)
+  (eieio--object-class obj))
+(define-obsolete-function-alias 'object-class #'eieio-object-class "future")
+;; CLOS name, maybe?
+(define-obsolete-function-alias 'class-of #'eieio-object-class "future")
+
+(defun eieio-object-class-name (obj)
+  "Return a Lisp like symbol name for OBJ's class."
+  (eieio--check-type eieio-object-p obj)
+  (eieio-class-name (eieio--object-class obj)))
+(define-obsolete-function-alias
+  'object-class-name 'eieio-object-class-name "future")
+
+(defmacro eieio-class-parents-fast (class)
+  "Return parent classes to CLASS with no check."
+  `(eieio--class-parent (class-v ,class)))
 
-(defun class-parents (class)
+(defun eieio-class-parents (class)
   "Return parent classes to CLASS.  (overload of variable).
 
 The CLOS function `class-direct-superclasses' is aliased to this function."
-  (if (not (class-p class)) (signal 'wrong-type-argument (list 'class-p class)))
-  (class-parents-fast class))
+  (eieio--check-type class-p class)
+  (eieio-class-parents-fast class))
+(define-obsolete-function-alias 'class-parents #'eieio-class-parents "future")
 
-(defmacro class-children-fast (class) "Return child classes to CLASS with no check."
-  `(aref (class-v ,class) class-children))
+(defmacro eieio-class-children-fast (class) "Return child classes to CLASS with no check."
+  `(eieio--class-children (class-v ,class)))
 
-(defun class-children (class)
-"Return child classes to CLASS.
+(defun eieio-class-children (class)
+  "Return child classes to CLASS.
 
 The CLOS function `class-direct-subclasses' is aliased to this function."
-  (if (not (class-p class)) (signal 'wrong-type-argument (list 'class-p class)))
-  (class-children-fast class))
+  (eieio--check-type class-p class)
+  (eieio-class-children-fast class))
+(define-obsolete-function-alias
+  'class-children #'eieio-class-children "future")
 
 (defun eieio-c3-candidate (class remaining-inputs)
-  "Returns CLASS if it can go in the result now, otherwise nil"
+  "Return CLASS if it can go in the result now, otherwise nil"
   ;; Ensure CLASS is not in any position but the first in any of the
   ;; element lists of REMAINING-INPUTS.
   (and (not (let ((found nil))
@@ -1691,7 +1722,7 @@
 
 (defun eieio-class-precedence-dfs (class)
   "Return all parents of CLASS in depth-first order."
-  (let* ((parents (class-parents-fast class))
+  (let* ((parents (eieio-class-parents-fast class))
 	 (classes (copy-sequence
 		   (apply #'append
 			  (list class)
@@ -1712,21 +1743,21 @@
 (defun eieio-class-precedence-bfs (class)
   "Return all parents of CLASS in breadth-first order."
   (let ((result)
-	(queue (or (class-parents-fast class)
+	(queue (or (eieio-class-parents-fast class)
 		   '(eieio-default-superclass))))
     (while queue
       (let ((head (pop queue)))
 	(unless (member head result)
 	  (push head result)
 	  (unless (eq head 'eieio-default-superclass)
-	    (setq queue (append queue (or (class-parents-fast head)
+	    (setq queue (append queue (or (eieio-class-parents-fast head)
 					  '(eieio-default-superclass))))))))
     (cons class (nreverse result)))
   )
 
 (defun eieio-class-precedence-c3 (class)
   "Return all parents of CLASS in c3 order."
-  (let ((parents (class-parents-fast class)))
+  (let ((parents (eieio-class-parents-fast class)))
     (eieio-c3-merge-lists
      (list class)
      (append
@@ -1739,7 +1770,7 @@
       (list parents))))
   )
 
-(defun class-precedence-list (class)
+(defun eieio-class-precedence-list (class)
   "Return (transitively closed) list of parents of CLASS.
 The order, in which the parents are returned depends on the
 method invocation orders of the involved classes."
@@ -1753,52 +1784,60 @@
       (:c3
        (eieio-class-precedence-c3 class))))
   )
+(define-obsolete-function-alias
+  'class-precedence-list 'eieio-class-precedence-list "future")
 
 ;; Official CLOS functions.
-(defalias 'class-direct-superclasses 'class-parents)
-(defalias 'class-direct-subclasses 'class-children)
-
-(defmacro class-parent-fast (class) "Return first parent class to CLASS with no check."
-  `(car (class-parents-fast ,class)))
-
-(defmacro class-parent (class) "Return first parent class to CLASS.  (overload of variable)."
-  `(car (class-parents ,class)))
-
-(defmacro same-class-fast-p (obj class) "Return t if OBJ is of class-type CLASS with no error checking."
-  `(eq (aref ,obj object-class) ,class))
+(define-obsolete-function-alias
+  'class-direct-superclasses #'eieio-class-parents "future")
+(define-obsolete-function-alias
+  'class-direct-subclasses #'eieio-class-children "future")
+
+(defmacro eieio-class-parent-fast (class)
+  "Return first parent class to CLASS with no check."
+  `(car (eieio-class-parents-fast ,class)))
+
+(defmacro eieio-class-parent (class)
+  "Return first parent class to CLASS.  (overload of variable)."
+  `(car (eieio-class-parents ,class)))
+(define-obsolete-function-alias 'class-parent #'eieio-class-parent "future")
+
+(defmacro same-class-fast-p (obj class)
+  "Return t if OBJ is of class-type CLASS with no error checking."
+  `(eq (eieio--object-class ,obj) ,class))
 
 (defun same-class-p (obj class) "Return t if OBJ is of class-type CLASS."
-  (if (not (class-p class)) (signal 'wrong-type-argument (list 'class-p class)))
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
+  (eieio--check-type class-p class)
+  (eieio--check-type eieio-object-p obj)
   (same-class-fast-p obj class))
 
 (defun object-of-class-p (obj class)
   "Return non-nil if OBJ is an instance of CLASS or CLASS' subclasses."
-  (if (not (eieio-object-p obj)) (signal 'wrong-type-argument (list 'eieio-object-p obj)))
+  (eieio--c...
 
[truncated message content]

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
> Here is a patch that attempts to clean up part of the EIEIO namespace.
> If you like it, please install it upstream, so it will get merged into
> Emacs later on.  If you prefer, I can install it into Emacs directly and
> you'll merge it later on upstream, of course.

Thank you for the patch. I know it cannot have been fun. :-)

I didn't have time yet to look at your patch in detail. I did apply it
to CEDET trunk and got byte-compile errors because there's
eieio-class-parent as well as eieio--class-parent.

As for the general direction of the cleanup: We did discuss this a bit
in the bug report you opened for it some time ago, and Eric stated that
he'd at least like to keep the CLOS-compatible names without having to
prefix everything with 'eieio-'. Your suggestion was to use the shorter
'cl-' prefix instead, and at least I think that is a good compromise. So
instead of using 'eieio-class-name', for instance, we'd rather use
'cl-class-name'. I don't know enough CLOS to see which other names are
affected by this (but I could easily look it up, of course).

Regarding the merge procedure: I'm a bit hesitant to merge the current
CEDET trunk to Emacs just yet because the Java-support is pretty much in
flux right now, so I'd prefer if you just apply it in Emacs trunk. We
were planning to move EIEIO development to Emacs trunk anyway. I'm
actually hoping that we can remove EIEIO from CEDET upstream some time
later this year.

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Eric M. L. <er...@si...>]

On 02/12/2013 05:10 PM, David Engster wrote:
> Stefan Monnier writes:
>> Here is a patch that attempts to clean up part of the EIEIO namespace.
>> If you like it, please install it upstream, so it will get merged into
>> Emacs later on.  If you prefer, I can install it into Emacs directly and
>> you'll merge it later on upstream, of course.
>
> Thank you for the patch. I know it cannot have been fun. :-)
>

Agreed.  Thanks for spending time on this.

[...]

> As for the general direction of the cleanup: We did discuss this a bit
> in the bug report you opened for it some time ago, and Eric stated that
> he'd at least like to keep the CLOS-compatible names without having to
> prefix everything with 'eieio-'. Your suggestion was to use the shorter
> 'cl-' prefix instead, and at least I think that is a good compromise. So
> instead of using 'eieio-class-name', for instance, we'd rather use
> 'cl-class-name'. I don't know enough CLOS to see which other names are
> affected by this (but I could easily look it up, of course).

I read through the patch, and tried to match up CLOS names that were 
affected by the rename.

For reference, here are some CLOS functions that were renamed in the patch:

class-name  -> eieio-class-name
http://www.lispworks.com/documentation/HyperSpec/Body/f_class_.htm

class-of (was alias to object-class)  -> obsoleted
http://www.lispworks.com/documentation/HyperSpec/Body/f_clas_1.htm

I didn't find anything else.

So on the whole, it didn't affect the CLOS functions much at all.  Good 
Stuff.

Thanks!
Eric

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>> I meant a compat package in CEDET upstream, so that it can run on older
>> Emacsen if we stop shipping our own EIEIO version.  As long as we're
>> obsolete-aliasing the old names, I don't see why we would need a compat
>> package in Emacs?
>
> Only if we can hope to get rid of those aliases soon, because we'd
> rather not have those compatibility aliases use up the namespace even
> when all the packages in use have been updated to use the "clean" names.

Well, you've started aliasing `class-name' in your patch, so I thought
that was the plan.

> For the CL package we solved this problem by leaving the "cl.el" package
> as a "compatibility package" only required by the packages that haven't
> been updated to use the new names.  CL was so widely used that it will
> take a *long* time to get rid of all uses of the old names, whereas
> EIEIO's use is not as pervasive, so we don't necessarily have to do the
> same for it.
> This said, maybe it would make sense to move "eieio.el" to "cl-eieio.el"
> (with clean names, autoloaded from cl-lib) and then make eieio.el
> into a simple compatibility package full of aliases.

What to do with the other files like eieio-base then? We cannot rename
it to cl-eieio-base.el because of name clashes, but it also provides
part of the public, CLOS-like functions.

To summarize the options so far:

1) Prefix everything with eieio- and be done with it. Create obsolete
   aliases for the old names and get rid of them "soon" (Emacs
   25?). Alternatively, create an eieio-compat package with aliases for
   the old names.

2) Prefix everything with eieio- and create cl- aliases for the
   CLOS-like functionality. Those aliases may be defined in

   2a) the eieio* files itself, or
   2b) in a separate cl-whatever.el file.

   As in 1), define obsolete aliases for the old names or use a compat
   package.

3) Rename eieio to cl-eieio with clean names (i.e., eieio- and
   cl-prefixes), autoloaded from cl-lib, and make eieio.el a simple
   compatibility package full of aliases.

I'm currently pretty much tied on "2b)+compat package" and 3).

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <monnier@IRO.UMontreal.CA>]

>> Only if we can hope to get rid of those aliases soon, because we'd
>> rather not have those compatibility aliases use up the namespace even
>> when all the packages in use have been updated to use the "clean" names.
> Well, you've started aliasing `class-name' in your patch, so I thought
> that was the plan.

Either these aliases will stay as they are until they're removed, or we
can move them to a separate package.  I saw no need to make such
a choice at this point.


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Eric M. L. <er...@si...>]

On 02/19/2013 02:49 PM, David Engster wrote:
> Stefan Monnier writes:
>> For the CL package we solved this problem by leaving the "cl.el" package
>> as a "compatibility package" only required by the packages that haven't
>> been updated to use the new names.  CL was so widely used that it will
>> take a *long* time to get rid of all uses of the old names, whereas
>> EIEIO's use is not as pervasive, so we don't necessarily have to do the
>> same for it.
>> This said, maybe it would make sense to move "eieio.el" to "cl-eieio.el"
>> (with clean names, autoloaded from cl-lib) and then make eieio.el
>> into a simple compatibility package full of aliases.
>
> What to do with the other files like eieio-base then? We cannot rename
> it to cl-eieio-base.el because of name clashes, but it also provides
> part of the public, CLOS-like functions.

There is nothing in eieio-base from CLOS.  Those are all just handy 
base-classes / concepts that I used elsewhere in CEDET.

> To summarize the options so far:
>
> 1) Prefix everything with eieio- and be done with it. Create obsolete
>     aliases for the old names and get rid of them "soon" (Emacs
>     25?). Alternatively, create an eieio-compat package with aliases for
>     the old names.
>
> 2) Prefix everything with eieio- and create cl- aliases for the
>     CLOS-like functionality. Those aliases may be defined in
>
>     2a) the eieio* files itself, or
>     2b) in a separate cl-whatever.el file.
>
>     As in 1), define obsolete aliases for the old names or use a compat
>     package.
>
> 3) Rename eieio to cl-eieio with clean names (i.e., eieio- and
>     cl-prefixes), autoloaded from cl-lib, and make eieio.el a simple
>     compatibility package full of aliases.
>
> I'm currently pretty much tied on "2b)+compat package" and 3).

I am fine with most of these ideas, but agree with David that option 3 
is pretty good.

Eric

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

>> Here is a patch that attempts to clean up part of the EIEIO namespace.
>> If you like it, please install it upstream, so it will get merged into
>> Emacs later on.  If you prefer, I can install it into Emacs directly and
>> you'll merge it later on upstream, of course.
> Thank you for the patch. I know it cannot have been fun. :-)

It was largely mechanical, tho.

> I didn't have time yet to look at your patch in detail.  I did apply it
> to CEDET trunk and got byte-compile errors because there's
> eieio-class-parent as well as eieio--class-parent.

Hmm.. there are both eieio-class-parent as well as eieio--class-parent,
but I'm not sure why that would cause a byte-compile error.

> As for the general direction of the cleanup: We did discuss this a bit
> in the bug report you opened for it some time ago, and Eric stated that
> he'd at least like to keep the CLOS-compatible names without having to
> prefix everything with 'eieio-'. Your suggestion was to use the shorter
> 'cl-' prefix instead, and at least I think that is a good compromise. So
> instead of using 'eieio-class-name', for instance, we'd rather use
> 'cl-class-name'. I don't know enough CLOS to see which other names are
> affected by this (but I could easily look it up, of course).

I don't know CLOS either.  I also don't know EIEIO enough to know for
sure which functions are "internal" (and can hence move to "eieio-" or
even "eieio--" without any problem) and which are "exported", so that
renaming them has to be done more carefully (with obsolete aliases).

> Regarding the merge procedure: I'm a bit hesitant to merge the current
> CEDET trunk to Emacs just yet because the Java-support is pretty much in
> flux right now, so I'd prefer if you just apply it in Emacs trunk.

OK.

> We were planning to move EIEIO development to Emacs trunk anyway. I'm
> actually hoping that we can remove EIEIO from CEDET upstream some time
> later this year.

Sounds good,


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Drew Adams writes:
>> Your suggestion was to use the shorter 'cl-' prefix instead,
>> and at least I think that is a good compromise.  So instead of
>> using 'eieio-class-name', for instance, we'd rather use
>> 'cl-class-name'.
>
> So does this mean that we can no longer know from the `cl-' prefix which library
> is involved?
>
> (I don't mean which file in the library, but which library.  In the past, `cl-'
> pretty much indicated library `cl' - either file cl.el or one of its related
> files cl-mac.el, cl-seq.el etc.)

That is certainly a valid concern. But I (and I guess Stefan, too) was
thinking more along the lines that 'cl' essentially means "common lisp",
and EIEIO being a CLOS implementation, this would make sense. Maybe it
would be cleaner to also rename the eieio- files to cl-clos-, but that
would break a lot of things out there.

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>> I didn't have time yet to look at your patch in detail.  I did apply it
>> to CEDET trunk and got byte-compile errors because there's
>> eieio-class-parent as well as eieio--class-parent.
>
> Hmm.. there are both eieio-class-parent as well as eieio--class-parent,
> but I'm not sure why that would cause a byte-compile error.

In toplevel form:
eieio.el:168:1:Error: Symbol's function definition is void: eieio--class-parent

I also cannot find a definition for eieio--class-parent, but maybe it's
hidden somewhere?

> I don't know CLOS either.  I also don't know EIEIO enough to know for
> sure which functions are "internal" (and can hence move to "eieio-" or
> even "eieio--" without any problem) and which are "exported", so that
> renaming them has to be done more carefully (with obsolete aliases).

Eric already posted links to the hyperspec where this can be looked
up. From your bug report #10781, the following names are from CLOS:

* Most of the slot-* names, like slot-boundp, slot-exists-p, etc.
* make-instance, initialize-instance
* with-slots
* class-name, class-of
* next-method-p, call-next-method
* defgeneric, defclass, defmethod

Now, whether to include them in the cl- or the eieio-namespace - I don't
have a terribly strong opinion on that one. If it's deemed too hack-ish,
then so be it, and we just prefix everything with eieio-. [Eric, if you
feel more strongly about those names, then please speak up. :-) ]

Actually, the most critical thing is 'oref' and 'oset', because this is
used extensively (~1800 times in CEDET), and it is not from
CLOS. Prefixing that with 'eieio-' would make code using EIEIO very
verbose, but I guess there's just no way around that...?

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Eric M. L. <er...@si...>]

On 02/13/2013 11:31 AM, David Engster wrote:
> Stefan Monnier writes:
>> I don't know CLOS either.  I also don't know EIEIO enough to know for
>> sure which functions are "internal" (and can hence move to "eieio-" or
>> even "eieio--" without any problem) and which are "exported", so that
>> renaming them has to be done more carefully (with obsolete aliases).
>
> Eric already posted links to the hyperspec where this can be looked
> up. From your bug report #10781, the following names are from CLOS:
>
> * Most of the slot-* names, like slot-boundp, slot-exists-p, etc.
> * make-instance, initialize-instance
> * with-slots
> * class-name, class-of
> * next-method-p, call-next-method
> * defgeneric, defclass, defmethod
>
> Now, whether to include them in the cl- or the eieio-namespace - I don't
> have a terribly strong opinion on that one. If it's deemed too hack-ish,
> then so be it, and we just prefix everything with eieio-. [Eric, if you
> feel more strongly about those names, then please speak up. :-) ]
>
> Actually, the most critical thing is 'oref' and 'oset', because this is
> used extensively (~1800 times in CEDET), and it is not from
> CLOS. Prefixing that with 'eieio-' would make code using EIEIO very
> verbose, but I guess there's just no way around that...?

I'm fine with renaming most EIEIO unique items with some eieio- flavor 
of prefix.  I know there is a debate of cl- vs eieio-.  Drew summed up 
well that EIEIO is an emulation of a subset of the OO parts of CLOS.  I 
think it is incomplete, particularly since it doesn't handle important 
aspects of method polymorphism, such as allowing method differentiation 
based on multiple input arguments, or against built-in types such as 
string or number.  Thus, my vote would be for an eieio- prefix since 
someday a better cl- or clos- variant might appear.

As for the names of CLOS methods, such as make-instance, etc. 
Personally, I think they should be left alone, but recognize that being 
a part of Emacs can come with a naming cost.  Unfortunately, that makes 
it hard to differentiate between CLOS parts and misc eieio internal parts.

I also think of oref/oset in the same bin as CLOS names such as 
make-instance, etc.  CLOS examples all use slot-value/setf instead of 
oref/oset.  setf is part of cl, and couldn't be used at runtime, so I 
mocked up the behavior with something matching aref/aset instead.  They 
are used all the time, and need a convenient name.  Having oref/oset use 
a different naming convention from the names from CLOS API would be 
inconvenient.

Eric

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <monnier@IRO.UMontreal.CA>]

> setf is part of cl, and couldn't be used at runtime, so I mocked
> up the behavior with something matching aref/aset instead.

Actually, there's a misunderstanding here:
- setf was indeed part of CL, but being a macro it was accepted
  (i.e. you don't need to have it defined at run-time, since it's
  macro-expanded during compilation).
- setf is part of core Elisp in Emacs-24.3.
So maybe we don't need oref/oset at all.

As for Drew's argument, in reality the "cl-" prefix was largely unused
until Emacs-24.3 (it was mostly used to mean "definition internal to
cl.el") where I introduced cl-lib (which does use "cl-" consistently
and replaced the former "cl-" of internal definitions to "cl--").

We could even justify the "cl-" prefix by making cl-lib autoload
`cl-slot-value' from eieio.el.  Or use the "eieio-" prefix everywhere
in eieio*.el and then define "cl-" aliases in cl-lib.el.




        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Xue F. <xfq...@gm...>]

On Thu, 14 Feb 2013 08:49:26 -0500
Stefan Monnier <monnier@IRO.UMontreal.CA> wrote:

> Or use the "eieio-" prefix everywhere
> in eieio*.el and then define "cl-" aliases in cl-lib.el.

I think it's a good choice.

-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <monnier@IRO.UMontreal.CA>]

> In toplevel form:
> eieio.el:168:1:Error: Symbol's function definition is void: eieio--class-parent

Can you (setq byte-compile-error t debug-on-error t) so as to get
a backtrace?

> I also cannot find a definition for eieio--class-parent, but maybe it's
> hidden somewhere?

It's defined (as a macro) by the call to (eieio--define-field-accessors
class ...)  which is kind of a "mini cl-defstruct".


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>> setf is part of cl, and couldn't be used at runtime, so I mocked
>> up the behavior with something matching aref/aset instead.
>
> Actually, there's a misunderstanding here:
> - setf was indeed part of CL, but being a macro it was accepted
>   (i.e. you don't need to have it defined at run-time, since it's
>   macro-expanded during compilation).
> - setf is part of core Elisp in Emacs-24.3.
> So maybe we don't need oref/oset at all.

Yes, although I like "(oset foo bar 'baz)" much better than the verbose

(setf (cl-slot-value foo 'bar) 'baz)

But I can understand that you want to get rid of it, and package writers
can still define their own macros/accessors.

Our problem on the CEDET side is that we want to stay compatible with
older Emacsen, so we'll need some compat package.

> We could even justify the "cl-" prefix by making cl-lib autoload
> `cl-slot-value' from eieio.el.  Or use the "eieio-" prefix everywhere
> in eieio*.el and then define "cl-" aliases in cl-lib.el.

Doesn't that mean that requiring cl-lib would load the full EIEIO
package?

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>> In toplevel form:
>> eieio.el:168:1:Error: Symbol's function definition is void: eieio--class-parent
>
> Can you (setq byte-compile-error t debug-on-error t) so as to get
> a backtrace?

Did you mean `byte-compile-error-on-warn'? Anyway, I'm afraid I just
don't get a backtrace with debug-on-error.

>> I also cannot find a definition for eieio--class-parent, but maybe it's
>> hidden somewhere?
>
> It's defined (as a macro) by the call to (eieio--define-field-accessors
> class ...)  which is kind of a "mini cl-defstruct".

I see. Now, I can compile your patched EIEIO with trunk, but using the
latest pretest gives me the above error. I can fix this by including the
define-field-accessor macro and its following two calls (for class and
object) in the 'eval-and-compile' clause. Not sure if that's the right
thing to do, though. Something must have changed in trunk in how this is
handled?

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

>> Actually, there's a misunderstanding here:
>> - setf was indeed part of CL, but being a macro it was accepted
>> (i.e. you don't need to have it defined at run-time, since it's
>> macro-expanded during compilation).
>> - setf is part of core Elisp in Emacs-24.3.
>> So maybe we don't need oref/oset at all.
> Yes, although I like "(oset foo bar 'baz)" much better than the verbose
> (setf (cl-slot-value foo 'bar) 'baz)
> But I can understand that you want to get rid of it, and package writers
> can still define their own macros/accessors.

I actually don't particular care if we keep them or not, except that if
we keep them, we need to give them a prefix.

> Our problem on the CEDET side is that we want to stay compatible with
> older Emacsen, so we'll need some compat package.

We can either introduce an eieio-compat package full of defaliases, or
do what we did with cl/cl-lib and turn eieio.el into a deprecated compat
package (and introduce a new package eieio-lib to replace it).

>> We could even justify the "cl-" prefix by making cl-lib autoload
>> `cl-slot-value' from eieio.el.  Or use the "eieio-" prefix everywhere
>> in eieio*.el and then define "cl-" aliases in cl-lib.el.
> Doesn't that mean that requiring cl-lib would load the full EIEIO
> package?

No, it can be autoloaded, like the definitions in cl-macs, cl-seq, and
cl-extra get autoloaded.


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

>>> In toplevel form:
>>> eieio.el:168:1:Error: Symbol's function definition is void: eieio--class-parent
>> Can you (setq byte-compile-error t debug-on-error t) so as to get
>> a backtrace?
> Did you mean `byte-compile-error-on-warn'? Anyway, I'm afraid I just
> don't get a backtrace with debug-on-error.

No, I meant byte-compile-debug sorry.

>>> I also cannot find a definition for eieio--class-parent, but maybe it's
>>> hidden somewhere?
>> It's defined (as a macro) by the call to (eieio--define-field-accessors
>> class ...)  which is kind of a "mini cl-defstruct".
> I see. Now, I can compile your patched EIEIO with trunk, but using the
> latest pretest gives me the above error. I can fix this by including the
> define-field-accessor macro and its following two calls (for class and
> object) in the 'eval-and-compile' clause.  Not sure if that's the right
> thing to do, though.  Something must have changed in trunk in how this is
> handled?

Let me get back to you on this one, later,


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>>>> In toplevel form:
>>>> eieio.el:168:1:Error: Symbol's function definition is void:
>>>> eieio--class-parent
>>> Can you (setq byte-compile-error t debug-on-error t) so as to get
>>> a backtrace?
>> Did you mean `byte-compile-error-on-warn'? Anyway, I'm afraid I just
>> don't get a backtrace with debug-on-error.
>
> No, I meant byte-compile-debug sorry.

Ah OK, I didn't know that one. Now I get a trace, but it's huge, so I
gzipped it.

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

>>>>> In toplevel form:
>>>>> eieio.el:168:1:Error: Symbol's function definition is void:
>>>>> eieio--class-parent
>>>> Can you (setq byte-compile-error t debug-on-error t) so as to get
>>>> a backtrace?
>>> Did you mean `byte-compile-error-on-warn'? Anyway, I'm afraid I just
>>> don't get a backtrace with debug-on-error.
>> No, I meant byte-compile-debug sorry.
> Ah OK, I didn't know that one. Now I get a trace, but it's huge, so I
> gzipped it.

eieio's extensive abuse of eval-and-compile is a real pain in the rear!
Does the additional patch below make it work for you?


        Stefan


--- lisp/emacs-lisp/eieio.el.orig       2013-02-17 12:06:09.252331190 -0500
+++ lisp/emacs-lisp/eieio.el    2013-02-17 12:06:20.336456193 -0500
@@ -121,10 +121,9 @@
                  (list 'aref x ,index))
               defs)
         (setq index (1+ index))))
-    `(progn
+    `(eval-and-compile
        ,@(nreverse defs)
-       (eval-and-compile
-         (defconst ,(intern (format "eieio--%s-num-slots" prefix)) ,index)))))
+       (defconst ,(intern (format "eieio--%s-num-slots" prefix)) ,index))))
 
 (eieio--define-field-accessors class
   (-unused-0 ;;FIXME: not sure, but at least there was no accessor!

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>>>>>> In toplevel form:
>>>>>> eieio.el:168:1:Error: Symbol's function definition is void:
>>>>>> eieio--class-parent
>
>>>>> Can you (setq byte-compile-error t debug-on-error t) so as to get
>>>>> a backtrace?
>>>> Did you mean `byte-compile-error-on-warn'? Anyway, I'm afraid I just
>>>> don't get a backtrace with debug-on-error.
>>> No, I meant byte-compile-debug sorry.
>> Ah OK, I didn't know that one. Now I get a trace, but it's huge, so I
>> gzipped it.
>
> eieio's extensive abuse of eval-and-compile is a real pain in the rear!
> Does the additional patch below make it work for you?

Yes, it now compiles.

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

>> eieio's extensive abuse of eval-and-compile is a real pain in the rear!
>> Does the additional patch below make it work for you?
> Yes, it now compiles.

Thanks.  I installed it into Emacs's trunk.


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[David E. <de...@ra...>]

Stefan Monnier writes:
>>> Actually, there's a misunderstanding here:
>>> - setf was indeed part of CL, but being a macro it was accepted
>>> (i.e. you don't need to have it defined at run-time, since it's
>
>>> macro-expanded during compilation).
>>> - setf is part of core Elisp in Emacs-24.3.
>>> So maybe we don't need oref/oset at all.
>> Yes, although I like "(oset foo bar 'baz)" much better than the verbose
>> (setf (cl-slot-value foo 'bar) 'baz)
>> But I can understand that you want to get rid of it, and package writers
>> can still define their own macros/accessors.
>
> I actually don't particular care if we keep them or not, except that if
> we keep them, we need to give them a prefix.

OK. I guess we'd have to use eieio-oref/oset then, since those functions
are not from CLOS (given that 'cl' means that thing I thought it means,
but I might just be confused :) ).

>> Our problem on the CEDET side is that we want to stay compatible with
>> older Emacsen, so we'll need some compat package.
>
> We can either introduce an eieio-compat package full of defaliases, or
> do what we did with cl/cl-lib and turn eieio.el into a deprecated compat
> package (and introduce a new package eieio-lib to replace it).

I meant a compat package in CEDET upstream, so that it can run on older
Emacsen if we stop shipping our own EIEIO version. As long as we're
obsolete-aliasing the old names, I don't see why we would need a compat
package in Emacs?

-David

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

> I meant a compat package in CEDET upstream, so that it can run on older
> Emacsen if we stop shipping our own EIEIO version.  As long as we're
> obsolete-aliasing the old names, I don't see why we would need a compat
> package in Emacs?

Only if we can hope to get rid of those aliases soon, because we'd
rather not have those compatibility aliases use up the namespace even
when all the packages in use have been updated to use the "clean" names.

For the CL package we solved this problem by leaving the "cl.el" package
as a "compatibility package" only required by the packages that haven't
been updated to use the new names.  CL was so widely used that it will
take a *long* time to get rid of all uses of the old names, whereas
EIEIO's use is not as pervasive, so we don't necessarily have to do the
same for it.
This said, maybe it would make sense to move "eieio.el" to "cl-eieio.el"
(with clean names, autoloaded from cl-lib) and then make eieio.el
into a simple compatibility package full of aliases.


        Stefan

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Vitalie S. <spi...@gm...>]

  >> Stefan Monnier <mo...@ir...>
  >> on Thu, 14 Feb 2013 17:16:21 -0500 wrote:

 >>> Actually, there's a misunderstanding here:
 >>> - setf was indeed part of CL, but being a macro it was accepted
 >>> (i.e. you don't need to have it defined at run-time, since it's
 >>> macro-expanded during compilation).
 >>> - setf is part of core Elisp in Emacs-24.3.
 >>> So maybe we don't need oref/oset at all.
 >> Yes, although I like "(oset foo bar 'baz)" much better than the verbose
 >> (setf (cl-slot-value foo 'bar) 'baz)
 >> But I can understand that you want to get rid of it, and package writers
 >> can still define their own macros/accessors.

 > I actually don't particular care if we keep them or not, except that if
 > we keep them, we need to give them a prefix.

Could please eieio-oref/eieio-oset be avoided?  oref/oset are so often
used that people will start aliasing them anyways.

How about replacing eieio-, the most awkward prefix in existence, with
simple "eo-", standing for Emacs Objects? Then eoref/eoset can be used
as (almost) namespace clean alternatives.

    Vitalie

Re: [cedet-eieio] Cleaning up the EIEIO namespace

[Stefan M. <mo...@ir...>]

> Could please eieio-oref/eieio-oset be avoided?  oref/oset are so often
> used that people will start aliasing them anyways.

CLOS seems to live just fine with `slot-value', so why not just use
`cl-slot-value'?
[ BTW, since setf is now part of core Elisp, we don't need oset.  ]

> How about replacing eieio-, the most awkward prefix in existence, with

Actually, I find it easy to type, because of the "ei" repetition and
because the "o" is right next to the "i".


        Stefan