(mapcar) and (lambda)
As you know, LISP stands for "List Processing". There are quite a few commands in AutoLisp that allow you to manipulate lists. (subst, append, etc.) But what about commands that will allow you to apply a function to items in a list. Let's look at (mapcar) first.
The function (mapcar) allows you to perform a "function" on each element of the list. Let's try a simple example :
What we want to do is add 1 to each element of a list.
(setq a 1) (mapcar '1+ (list a))
This will return 2.
This is what happened :
mapcar adds 1 to the
(list a) to make 2.
Now a longer list :
(setq a '(1 2 3 4 5 6 7 8 9 10)) (mapcar '1+ a)
This will return :
(2 3 4 5 6 7 8 9 10 11)
Just a few words on creating lists in AutoLisp: there are two ways to create lists. The first way is to use a command that will create a list. Examples of this are
(entget). Both of these commands will return a list.
Secondly, you could use the
(list) command. For example :
(setq a (list 1 2 3 4 5))
If you looked at variable a it would look like this :
(1 2 3 4 5)
The other way of writing this is :
(setq a '(1 2 3 4 5))
Both methods do the same thing, create a list.
Here is another example using
Say you have a list of data stored in variable arglist.
(setq arglist '(12.0 145.8 67.2 "M20"))
You want to place each item in the list in it's own variable to use in your routine. One way to do it would be as follows :
(setq a (nth 0 arglist)) (setq b (nth 1 arglist)) (setq c (nth 2 arglist)) (setq d (nth 3 arglist))
This works, but is an extremely slow way of processing the data as each variable requires a program statement. A much more efficient way is to use the MAPCAR technique.
(mapcar 'set '(a b c d) arglist)
This routine maps the SET function to each element of the first list and it's corresponding element of the second list. SET is used instead of SETQ to evaluate each quoted element of the first list. With the currently set list c, it sets a to 12.0, b to 145.8, c to 67.2 and d to "M20".
If you are reading a list from an external file, your routine may not read back the elements of the list as they once were. Your routine will read them back as strings. For example :
Your list should look like this :
(10 20 30 40 50)
But after reading the list in from the file, it looks like this :
("10" "20" "30" "40" "50")
You can use (mapcar) to convert the list from strings to integers :
(setq b (mapcar '(atoi) thelist))
Now this works fine if you are using an AutoLisp function, but how would you use
(mapcar) with a user defined function? Let's look at this example :
What we have is a list of angles that we want to convert to Radians.
(setq c '(23.0 47.8 52.1 35.6))
Firstly we would write a function to convert degrees to radians :
(defun dtr (a) (* pi (/ a 180.0)) )
Our function to convert our list would look like this :
(setq d (mapcar 'dtr c))
This function will run the
(dtr) function against each element of list c. In other words, the value of each element is passed to the (dtr) function.
The function could also be written like this :
(setq d (mapcar (quote dtr) c))
Now this is where the
(lambda) function comes into play.
(lambda) allows you to write the
(dtr) function "in-line" within the
(mapcar) expression without having to define a separate function.
(setq d (mapcar (quote (lambda (a) (* pi (/ a 180.0)))) c))
(setq d (mapcar '(lambda (a) (* pi (/ a 180.0))) c))
This function will convert all the angles in the list c to radians and store them in variable d.
Let's look a bit closer at the
(lambda (a) (* pi (/ a 180.0)))
…is the same as…
(defun (a) (* pi (/ a 180.0)))
Let's write a function to test this :
(defun c:test () (setq c '(23.0 47.8 52.1 35.6)) (setq d (mapcar '(lambda (a) (* pi (/ a 180.0))) c)) (mapcar 'set '(w x y z) d) (princ) )
!c should return
(23.0 47.8 52.1 35.6)
!d should return
(0.401426 0.834267 0.909317 0.621337)
!w should return
!x should return
!y should return
!z should return
To quote the AutoCad Customization Manual :
"Use the (lambda) function when the overhead of defining a new function is not justified. It also makes the programmer's intention more apparent by laying out the function at the spot where it is to be used."
(lambda) can be used anywhere you need a speedy function and you don't want the trouble of writing and making sure a
(defun) function is loaded.
There are another two AutoLisp commands that can apply a function to a list. They are
(foreach). Let's have a quick look at them.
This function differs from (mapcar) in that it applies a function to the whole list and not to the individual items in the list. Here's a couple of examples :
(apply '+ '(1 2 3))
This will return 6.
(apply 'strcat '("a" "b" "c"))
This will return "abc"
You can also use
(apply) in comjunction with
(apply '(lambda (x y z) (* x (- y z)) ) '(5 20 14) )
This will return 30 (20-14*5=30).
The syntax for this is:
(foreach name list expression…)
This function steps through list, assigning each element to name, and evaluates each expression for every element in the list. For example :
(foreach n a (princ n) (terpri))
If you had a list :
(setq a (1 2 3 4 5))
The previous expression would print vertically :
1 2 3 4 5
Right, I don't know about you, but my brain is full. Time for a couple of beers. Cheers for Now…