(and (keep calm) (hack lisp))

Hello there !

I made a small presentation about lisp at a functional programming event at SFEIR. In fact, it was more an intro than "hacking" into it.

This post explains a few things and some examples I used during this talk.

The slides are here.

First, I introduced John McCarthy (the guy who invented lisp) and Dennis Ritchie (you should know this guy, who admired lisp). They died in october 2011, I just wanted the audience to remember that Steve Jobs is not the only guy who died at this time...

Then, I talked about lisp, the spec and some implementations.

And Polish notation (Let me wikipedia that for you).

With a nice clisp REPL open, I started showing a few examples (> represent the REPL input):

> (print "Hello World !")
"Hello World !"
"Hello World !"

Why is "Hello World !" printed 2 times ?

Because everything returns something. The print function prints the given arguments and then returns the data. It is useful for things like:

> (+ (print 1) (print 2))
1
2
3

which print 1, then 2, and finally the computation of (+ 1 2) which is 3.

Variables

I explained the differences between defvar, defparameter, setq and let.

defvar and defparameter

defvar and defparameter are used to set variables. The latter one is, as I read, used for values that can have an effect on the program (I took the example of a ratio that can be modified and used in function bodies).

> (defvar *kikoo* "plop")
*KIKOO*
> *kikoo*
"plop"

defconstant

Used for constants ! I used the following code to show the re-assignment warning, and to show that the final value was "plip".

> (defconstant *const* "plop")
> (defconstant *const* "plip")
> *const*
"plip"

setq

I used the following code to describe how setq works for multiple variables and computations.

> (defvar a)
A
> (defvar b)
B
> (defvar c)
C
> (setq a 1 b 2 c 3)
3
> (setq a (+ 1 b) b (+ 1 a) c (+ a b))
7

let

I should also have talked about let* but I forgot what was the difference... The last x is not defined since the let declaration is scoped, so I got an error.

> (let ((x 1) (y 2))
(+ x y))
3
> x
*** - SYSTEM::READ-EVAL-PRINT: variable X has no value
Rentrées possibles:
USE-VALUE      :R1      Input a value to be used instead of X.
STORE-VALUE    :R2      Input a new value for X.
ABORT          :R3      Abort main loop

Functions

defun

I created 2 functions, a good old "hello world" and one with a parameter. Note that when defining a function, the name of the function is returned.

> (defun hello-world ()
(print "Hello, World!"))
HELLO-WORLD
> (hello-world)
"Hello World !"
"Hello World !"

I used format instead of print to introduce NIL (format doesn't return the data, but the NIL value).

> (defun hello-toto (name)
(format t "Hello, ~a" name))
HELLO-TOTO
> (hello-toto "彩子")
Hello, 彩子
NIL

funcall, lambda

They are used to "apply" a function to an arguments list. I chose to also introduced a lambda function.

> (funcall (lambda (x) (+ x 3)) 4)
7

Conditions and predicates

I introduced quickly if and the über powered alternative cond. Also, predicates for everythings !

> (defun test-thing (thing)
(print (if thing "yep" "nope")))
TEST-THING
> (test-thing "plop")
"yep"
> (test-thing NIL)
"nope"

Loops

I didn't talk about them. Next time !

Lisp stands for LISt Processing

Why choose a lisp instead of everything else ? List manipulations are one of lisp's super powers.

I introduced cons and the quote operator.

> (cons 1 (cons 2 (cons 3 (cons 4 nil))))
(1 2 3 4)
> '(1 2 3 4)
(1 2 3 4)

Also, car:

> (car '(1 2 3))
1

And its buddy cdr:

> (cdr '(1 2 3))
(2 3)
> (mapcar (lambda (x) (* x 2)) '(1 2 3 4 5))
(2 4 6 8 10)

Magic operators

quote or '

In lisp, code is data ! You can use quote to not evaluate a list (in the second example, setq is not processed).

> (setq a 3)
3
> '(setq a 3)
(SETQ A 3)

backquote / quasiquote and comma

Quasiquote is like the previous quote, but you can use comma , to evaluate the following expression:

> (let ((s 'hello))
`(,s world))
(HELLO WORLD)

sharpsign-quote

It's like funcall or apply.

> (mapcar #'sqrt '(1 2 3 4 5))

HOLY MACROS

DEFMACRO, MACROEXPAND

The macro

> (defmacro let1 (var val &body body)
`(let ((,var ,val))
,@body))
LET1

The use

Allows to understand in a simple way the macro code. In this example:

> (let1 foo (+ 2 3)
(princ "Lisp is awesome!")
(* foo foo))
• var is foo
• val is (+ 2 3)
• body is (princ "Lisp is awesome!") and (* foo foo)

The macro body (after the quasiquote) shows that we use the evaluated values of var and val in a let. So we define a variable with the name foo and the value (+ 2 3).

Then the body is evaluated:

• (princ "Lisp is awesome!") prints Lisp is awesome!
• (* foo foo) is evaluated to (* (+ 2 3) (+ 2 3)) and prints 25.

The expansion

Shows the expanded code from the macro, and returns T (true) if it has been expanded:

> (macroexpand '(let1 foo (+ 2 3)
(* foo foo)))
(LET ((FOO (+ 2 3))) (* FOO FOO)) ;
T

How to macros ?

3 steps:

• write sample call and expansion
• write generative code
• prevent leaks