Custom Query (1030 matches)

It seems the way ignore or ignorable declarations are implemented with defsetf doesn't make them entirely ignored, since a warning is still issued, and indeed, an uninterned symbol used in place of the parameter is still present and not declared anymore as ignored or ignorable.

(defgeneric bug (x y &optional z))

(defmethod bug ((x integer) y &optional z)
  (declare (ignorable z))
  (+ x y))

(defmethod bug ((x string) y &optional z)
  (list (aref x y) z))

(defun set-bug (x y new-value)
  (+ x y new-value))

(defsetf bug (x y &optional z) (new-value)
  (declare (ignorable z))
  `(set-bug ,x ,y ,new-value))

(defun f ()
  (setf (bug 42 0) 33))

(eval-when (:load-toplevel :execute)
  (pprint (swank-backend:macroexpand-all
           '(defun f ()
             (setf (bug 42 0) 33)))))


#|

dictionary> (load (compile-file  #P"~/ccl-bug.lisp"))

;Compiler warnings for "home:ccl-bug.lisp.newest" :
;   In f: Unused lexical variable #:z

(progn (ccl::%defun (ccl:nfunction f
                                   lambda
                                   nil
                                   (declare (ccl::global-function-name f))
                                   (block f
                                     (let* ((#:g90598 42) (#:g90597 0))
                                       (declare (ignorable #:g90598 #:g90597))
                                       (multiple-value-call
                                         (lambda (&optional #:g90596 &rest #:ignore)
                                           (declare (ignore #:ignore))
                                           ((lambda (#:x #:y &optional #:z) (set-bug #:x #:y #:g90596))
                                            #:g90598 #:g90597))
                                         33))))
                    'nil)
       'f)#P"/home/pjb/ccl-bug.lx64fsl"
|#

(defun f () (setf (symbol-function 'f) (lambda () 1)) (f))

Such a function will cause an infinite loop when it is call at first time but when interupting and calling (f) again, it has been modified to (lambda () 1) I have tried several CL implementation and they all behave correctly, they return 1 and do not cause an infinite loop.

Welcome to Clozure Common Lisp Version 1.10-dev-r15846M-trunk  (DarwinX8664)!
? (directory #P"~/directory-with-one-subdirectory/**/")
> Error: The value NIL is not of the expected type STRUCTURE.
> While executing: CCL::%PROCESS-DIRECTORY-RESULT, in process Listener(4).
> Type cmd-. to abort, cmd-\ for a list of available restarts.
> Type :? for other options.
1 > 

This used to work.

Welcome to Clozure Common Lisp Version 1.10-dev-r15778M-trunk  (DarwinX8664)!
? (directory #P"~/directory-with-one-subdirectory/**/")
(#P"/Users/alms/directory-with-one-subdirectory/" #P"/Users/alms/directory-with-one-subdirectory/the-one-subdirectory/")
?