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.

The problem with anonymous lambda functions is, that they can’t call themselves recursively, since – well they’re anonymous and hence don’t have a name. To get passed this problem, you can let it have an additional function parameter which it will call in place where the recursion would normally take place.

An example for a reverse function, which reverses the elements of its argument (a list) with the help of an accumulator list (which holds the reversed list) could be written like this, without using an additional function:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list &optional (acc nil))
  (let ((head (car list)) (rest (cdr list)))
    (cond
      (head
       (cond
	 ((atom head)
	  (myreverse rest (cons head acc)))
	 (t
	  (myreverse rest (cons (myreverse head) acc)))))
      (t
       acc))))

But, as you can see, the accumulator list is part of the function’s argument list, although optional. To make this function a little bit ’safer’, it shouldn’t be part of the ‘public interface’ of the function. So you’d probably come up with something like this, where you’d use an anonymous helper function, which takes the additional accumulator list and returns it when it’s done reversing the original list:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list)
  (let ((reverse-acc #'(lambda (func list acc)
			(let ((head (car list)) (rest (cdr list)))
			  (cond (head
				 (cond ((atom head)
					(funcall func func rest (cons head acc)))
				       (t
					(funcall func func rest (cons (funcall func func head nil) acc)))))
				(t
				 acc))))))
    (funcall reverse-acc reverse-acc list nil)))

But, as you can see, since anonymous functions can’t call themselves recursively, you need to give it another extra parameter, a function object, which actually gets filled with the anonymous function itself, so it can call itself inside its body. But, fortunately, theres an even better version how to do exactly this in lisp: With the labels special operator, which defines local functions with a given name (like normal functions) which can then get called inside the function body itself and in the body-form of the macro:

1
2
3
4
5
6
7
8
9
10
11

(defun myreverse (list)
  (labels ((myreverse-acc (list acc)
	     (let ((head (car list)) (rest (cdr list)))
	       (cond (head
		      (cond ((atom head)
			     (myreverse-acc rest (cons head acc)))
			    (t
			     (myreverse-acc rest (cons (myreverse-acc head nil) acc)))))
		     (t
		      acc)))))
    (myreverse-acc list nil)))

As you can see, this version is nicer than the first or the second, since it hides the fact, that the reverse function uses an accumulator list and that it is also easier to understand, since you can use an actual name for the function instead of passing the function as an argument to itself, in ordner to make a recursive call. So basically, you can think of a function defined with the labels special operator as a local defun, which I think is really nice.

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.

I guess this is my third attempt to start a webblog. Oh well.

I hope to actually make posts at a decent rate this time, since that was my main problem the last two times i started a weblog.

So, what has changed? What is this blog about? Why am I doing this?

First of all, there’s lots of interesting new stuff going on in my life. Since this blog should obviously reflect my personal interests and stories, it will mainly be about what I like to do best: programming and software / computers in general.

I have been programming in Ruby for quite a while now – mainly webprogramming but theres also a little side project called “RSwing” which basically is a Jruby wrapper of the Java Swing GUI-Framework. And more recently I have started to learn Common Lisp which I also find very exciting and have lots of stuff to post about here.

So hopefully, if I manage to actually pull this through, there will be some updates on my current software projects and other stuff related to computers and my hobbies.