Comments on: A lisp macro virgin tells all

By: Steve

Steve — Thu, 26 Jun 2008 23:35:48 +0000

jeff: --

I don't think so in all cases, but it certainly works for some.

Also, it's just prettier to write

(domanytimes (x 10 y 10)
  (print (* x y))

than it is to write

(domanytimes (x 10 y 10) (lambda (a b) (print (* a b))))

By: jeff

jeff — Thu, 26 Jun 2008 20:03:38 +0000

can’t u just do the same thing with a function that takes a closure as an arg. You would have the loop in this function call the closure.

By: Steve

Steve — Tue, 24 Jun 2008 23:53:34 +0000

timbo: --

I actually meant it this way round, since this is the form you'd see in an SQL statement. Inside a macro, you can rewrite the list

'(DUEDATE > TODAY)

into your second form, within the body of the macro. SQL programmers don't get as thrown.

By: Timbo

Timbo — Tue, 24 Jun 2008 10:03:58 +0000

(....(DUEDATE > TODAY))

???

(....(> DUEDATE TODAY))

Excellent work, otherwise.

By: Steve

Steve — Tue, 13 May 2008 18:24:31 +0000

@Foo:

Thanks for taking the time to code this, Foo. I appreciate it.

By: Foo

Foo — Tue, 13 May 2008 18:05:52 +0000

Try this one, which is more in the spirit of dotimes. If there are zero loop-list items, it runs the body once and returns nil. Else it works like yours except if there's an extra single expression at the end of the loop-list it evaluates and returns it afterwards; else it returns nil.

(defmacro domanytimes (loop-list &rest body)
  (if (oddp (length loop-list))
      `(progn (domanytimes ,(butlast loop-list 1) ,@body)
          ,(first (last loop-list)))
      (if loop-list
      `(dotimes ,(subseq loop-list 0 2)
         (domanytimes ,(rest (rest loop-list)) ,@body))
      `(progn ,@body))))

By: Steve

Steve — Tue, 15 Apr 2008 18:19:58 +0000

@bob

Thanks, Bob!

I haven’t got to destructuring-bind yet…

By: Bob Bane

Bob Bane — Tue, 15 Apr 2008 16:09:56 +0000

Your macro would be slightly prettier (and a little more Lisp-idiomatic) like this:

(defmacro domanytimes (loop-list &body body) (if (null loop-list)

(progn ,@body)
      (destructuring-bind
         (fst rst . tail) loop-list

(dotimes (,fst , rst) (domanytimes ,tail ,@body)))))

Untested, and I hope I got the markup right...

By: leppie

leppie — Tue, 15 Apr 2008 06:26:56 +0000

@Steve:

Even I have to use it secretly at work!

By: jay

jay — Tue, 15 Apr 2008 04:24:39 +0000

this actually works I had to separate the variable names from the values. The implementation is a little longer because DoManyTimes is a class and maintains state to pass to the block.

DoManyTimes.run([3,3,3]) do |x,y,z| puts “#{x} #{y} #{z}” end

You can use an arbitrary number of indices. DoManyTimes([10,10,10,10,10]) do {x,y,z,a,b| … end

I’m sure there is a better way to do this in ruby, but I got sidetracked because I realized it would be a lot easier in javascript, I think