(defparameter *handlers-1* nil)

(defun reg-handler-1 (fun)
  (let ((real-fun (typecase fun
                    (symbol (symbol-function fun))
                    (function fun)
                    (t (error "Invalid type")))))
    (push real-fun *handlers-1*)))

(defun call-handlers-1 ()
  (dolist (handler *handlers-1*)
    (funcall handler)))

(defparameter *handlers-2* nil)

(defun reg-handler-2 (fun)
  (unless (typep fun '(or function symbol))
    (error "Invalid type"))
  (push fun *handlers-2*))

(defun call-handlers-2 ()
  (dolist (handler *handlers-2*)
    (typecase handler
      (symbol (funcall (symbol-function handler)))
      (function (funcall handler)))))

(defun foo ()
  (format t "def 1!~%"))

(reg-handler-1 #'foo)
(reg-handler-1 'foo)

(reg-handler-2 #'foo)
(reg-handler-2 'foo)

(call-handlers-1)
(call-handlers-2)

;; eval interactively!

;; (defun foo ()
;;   (format t "def 2!~%"))

;; (call-handlers-1)
;; (call-handlers-2)