Comments on: Lisp Troubles: Fabricating a Closure…

By: pat

pat — Thu, 08 Oct 2009 16:06:31 +0000

I thought about that for a bit here, too. In this case though, I would then need to be sure that special was appropriately bound during each invocation of my lambda.

By: raito

raito — Thu, 08 Oct 2009 15:55:49 +0000

I had a similar problem some time ago, where EVAL took place in a null lexical environment, but needed to use some stuff defined in the function that contained the EVAL. My solution was to declare the stuff I needed inside the EVAl as special, giving it dynamic scope. Because the EVAl took place in the dynamic scope that included the special variables, I was able to access them from inside the EVAL. It looed something like this:

;not all the code, but you get the picture.
(defun name (arg1 arg2)
     (declare (special arg1 arg2))
...
     ; the code in (nth item results) can access arg1 and arg2
     (eval (nth item results)))

By: pat

pat — Thu, 08 Oct 2009 14:11:44 +0000

That… Is… Crafty….

Very nice. Thank you.

By: tfb

tfb — Thu, 08 Oct 2009 13:48:52 +0000

You were close with

(defun generate-setter (array pre post)
  (eval `(lambda (index value)
           (setf (aref array ,@pre index ,@post) value))))

If you generate a function that, when called, returns the closure, you can get what you were trying for there.

(defun generate-setter (array pre post)
  (let ((make-closure
         (eval `(lambda (array)
                  (lambda (index value)
                    (setf (aref array ,@pre index ,@post) value))))))
    (funcall make-closure array)))

And of course, you probably want to replace EVAL with COMPILE…

By: pat

pat — Thu, 08 Oct 2009 12:52:20 +0000

I thought that the (APPLY …) would totally mess with (SETF …)‘s head. Though, I suppose that I didn’t try it that way. That was my first implementation of the non-SETF version of this function. I see now where there is an example of using (APPLY #’AREF …) in a (SETF …) in the Hyperspec. Thanks for pointing that out.

If I can just get the closure part to work then, I’ll have a much more readable version than all this messing with ARRAY-ROW-MAJOR-INDEX.

(As for the tag: It wasn’t tagged Lisp because I’m still lame with WordPress. I typed in “lisp” into the tags box. It showed me the list of auto-completes, and I thought I was done. I forgot that I have to commit the tags with an “enter” or a mouse click… having the tags there when I hit “Publish” isn’t enough. Oops.)

By: pat

pat — Thu, 08 Oct 2009 12:31:56 +0000

No… I haven’t looked at Bordeaux FFT. It didn’t come up when I searched for FFT on the Cliki or when I searched for FFT and Lisp together on Google. I will look at it.

Actually, it’s on my first page of Google results at the moment. I don’t know what I had searched for before, or how I had missed it. Definitely, it could use a mention on the Cliki.

By: Zach

Zach — Thu, 08 Oct 2009 12:21:35 +0000

The simple, straightforward implementation could look like this due to how APPLY and AREF are specified to work together:

(defun (setf row-ref) (value row index)
  (with-slots (array pre post) row
    (setf (apply #'aref array (append pre (list index) post)) value)))

(Why isn’t this post tagged “lisp”?)

By: michaelw

michaelw — Thu, 08 Oct 2009 08:54:21 +0000

Hi, not answering your question, really, but have you looked at bordeaux-fft?

By: pat

pat — Thu, 08 Oct 2009 06:57:45 +0000

Feh, I suppose that I can get away with it if I pass in the buffer each time. I’d rather have a closure, but this will work at the expense of having to pull the buffer out of my virtual-row each call:

(defun generate-setter (pre post)
  (eval `(lambda (buffer index value)
           (setf (aref buffer ,@pre index ,@post) value))))