I’ve been programming Lisp for a little while now and always have been looking for some video tutorials (or screencasts) about Common Lisp or Lisp programming in general but haven’t found so many.
Also doing some Ruby stuff, I always enjoyed the huge amount of videos online and thought that there should be more Lisp related screencasts as well.

So, I thought about starting my own. And here it is

You can download the Quicktime file here: Lisp Screencast #01: Macros

Or also watch it on my Blip.tv channel:

Any comments? Feel free to send me a mail or post a comment here.

I’ll try to make this a regular thing for the future. Any topic suggestions are also welcome.

new while macro

1
2
3
4
5
6
7
8

;; while macro with tagbody & go.
(defmacro while-new (condition &body body)
  (let ((tag-name (gensym)))
    `(tagbody
      ,tag-name
      ,@body
      (when ,condition
	(go ,tag-name)))))

Thanks again to the anonymous commenter ‘foo’, who made it clear, that the previous version (without gensymed-symbols) could make trouble in the case of a caller having symbols defined with the same name (in this case tag-name).

I also changed the foreach-macro to use gensymed symbols:

new foreach macro

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

;; foreach macro with tagbody & go.
(defmacro foreach-new ((var list) &body body)
  (let ((tmp-list (gensym)) (start-tag (gensym)))
    `(let* ((,tmp-list ,list) (,var nil) (rest (cdr ,tmp-list)))
       (tagbody
	  ,start-tag
	  (if (null ,tmp-list)
	      nil
	      (progn
		(setf ,var (car ,tmp-list))
		(setf rest (cdr ,tmp-list))
		(if ,var
		  (progn ,@body
			 (setf ,tmp-list rest)
			 (go ,start-tag))
		  nil)))))))

new until macro

1
2
3
4

;; until macro reusing new while macro.
(defmacro until-new (cond &body body)
  `(while-new (not ,cond)
     ,@body))

Also, thanks to ‘foo’, who pointed this out in some comments.
I’ve known about this fact for little while already, but haven’t thought about posting it here. Since some people might be reading this and wondering, why they don’t seem to work, they now should have some working samples.

It basically does the same as the predefined dolist-macro, but oh well

foreach macro

1
2
3
4
5
6
7
8
9
10

;; foreach-loop, similar to those in Java or C#
;; example: (foreach (x '(1 2 3))
;;                               (print x))
(defmacro foreach ((var list) &body body)
  `(let ((,var (car ,list)) (rest (cdr ,list)))
    (if ,var
	(progn
	  ,@body
	  (foreach (,var rest) ,@body))
	nil)))

I’ve also come up with my own file-handling macro, similar to the predefined with-open-file:

with-file macro

1
2
3
4
5

;; can be used like with-open-file macro
(defmacro with-file ((filestream-var filename &optional &key (if-exists nil) (direction :input)) &body body)
  `(let ((,filestream-var (open ,filename :direction ,direction :if-exists ,if-exists)))
    ,@body
    (close ,filestream-var)))

At first macros seemed to be something complicated, but once I’ve started reimplementing some of the standard macros and also making up my own custom ones, it really got much clearer to me how they work and why they are so important. Especially the with-file macro gives you an idea of whats possible with macros. Abstracting away the pattern of opening a file, doing something and then closing it again is just really nice, since you won’t ever forget to close it again, if you stick with using the macro.

I’ll try to come up with some more soon.

Next big thing on my agenda is some file in- and output as well as CLOS, the powerful Common Lisps Object System.

Here’s what I’ve done so far:

while macro:

1
2
3
4
5
6
7
8

;; example:
;; (defparameter x 0)
;; (while (< x 10) (print x) (incf x)) ;; output numbers 0 - 9.
(defmacro while (cond &body body)
  `(if ,cond 
    (progn ,@body 
	   (while ,cond ,@body))
    nil))

until macro

1
2
3
4
5
6

;; example: (until (= x 10) (print x) (incf x))
(defmacro until (cond &body body)
  `(if (not ,cond)
    (progn ,@body
	   (until ,cond ,@body))
    nil))

for macro

1
2
3
4
5
6
7

;; example:
;; (for ((i 0) (< i 10) (incf i))
;;      (print i))
(defmacro for (((var init-value) cond step-block) &body body)
  `(do ((,var ,init-value ,step-block))
    ((not ,cond))
    ,@body))

I started this yesterday and I’ll try to come up with some more. Lets see what else i can come up with
Not that this is particularly useful or anything since you really don’t need them, but it’s still a nice way to learn the language and especially how macros work. I’ll just keep it as a little exercise to myself in order to get to know common lisp in greater detail.