, We're now going to move on to a different but slightly related topic which
is macros. The way this is going to work is in this segment I just want to give you
the high-level ideas of what a macro is so that in the next section, when we use that
idea For a few things you're familiar with the idea. Do not need it for this sections
homework, unless you attempt to do the challenge problem. So the way this is
going to work is that after this segment I will go into the details of Racket's macro
system. Some of the general pitfalls of macros, using this in Racket is actually a
great idea because Racket's macro system avoids a lot of the pitfalls and
weaknesses of other macro systems, particularly the more well-known macros of
C and CC++, but I've decided to make all the segments after this one optional,
because macros are a bit of a standalone topic, and we're not really going to build
on them very much in the course. So it's sort of up to you, and this is an
opportunity to save time and focus on other topics that fit more into the other
core material in the class. You do need to know a few things, so let's go through
that. And let's start with just what is a macro? So when you define a macro, it
describes how to transform some new syntax into different syntax in the source
language. I basically like to think of a macro definition as adding more syntactic
sugar to the language. And if we let programmers define their own macros, then
they get to extend the syntax of the language by introducing new syntactic
sugar. For example, maybe we could have something that lets you add the andalso
keyword to Racket in some way. And that, that would turn into the conditional that
we know, andalso in ML, is syntactic sugar for. a macro system is just a language you
give programmers for defining macros. And then what happens, is after someone has
defined a macro, then someone can use that macro just like you define a function and
then you use it. When a macro is used that macro is expanded, you take the syntax at
the use, and you transform it into the de-sugared version, according to the rules
in the macro definition. And the key thing about the way macro systems work, is that
expansion happens before anything else we've talked about in this class. You take
the program the programmer wrote down, you go through and you expand all the macro
uses first, before you type check, if you're in a statically typed language,
before you evaluate anything. So you do macro expansion in function bodies, you do
it in conditional branches. It really is a pre-pass before you do anything else, and
that's the idea of macros. So in Racket, just to get a little more specific, so we
can actually see some examples, if someone defines a macro m, then m just becomes a
new special form. So after that macro definition, someone can use it. By writing
m and then whatever other arguments that macro needs and then, due to macro
expansion, that will get replaced as though it's syntactic sugar, So here's a
few examples, then the later optional sections we'll learn how to define. Here I
just want to show how you might use them. So first, suppose someone didn't like
Racket's if, because you know, they, they didn't understand which one was the then
and this is the else. They could define their own macro, where you write my-if,
then some expression, then other keywords, then and else, with e2 and e3. So e1, e2,
and e3 are expressions. my-if, then and else are all part of the syntax, and macro
expansion would expand that to if e1, e2, e3. Okay.
That seems somewhat useful, not too exciting. Here's one that's also maybe not
too exciting. You could write a macro, comment-out, that took two pieces of
syntax, two arbitrary expressions, and in the expansion, got rid of e1. So the idea
is that we want to comment-out e1, but we need to put something in its place, and so
that will be e2. So it doesn't, because this is done before anything else we do,
that e1 will never be evaluated. As a final example to relate back to something
we did earlie r in this section, we could define a macrel for creating promises,
somebody of my-delay, that would take an expression and by putting it under a
lambda in the macro expansion, will make sure it does not get evaluated. And that's
something that you simply can't do, if you try to define my-delay as a function. So
let's see how we might do this. I've already clicked run, where I have
definitions of all these things. And I really did define them. So for example, I
could define, I could use the my-if macro. This is not something in Racket, I defined
a macro that let me do this, and, you know, 7 actually comes out to 7. And you
even get an error message if you screw something up, like write else in both
places. It says bad syntax, the definition of the macro doesn't allow you to put an
else in that position. let me show you the comment-out macro. if I did something like
comment-out, how about car of null? We know car of null will raise an error as
soon as you try to do it, but because macro expansion replaces this entire thing
with false, I get no error and I just get false.
We, you know, just to be clear, if I had actually tried to do car of null, I would
get an error. And finally, let's look at my delay a little bit. So, let's say, P of
my delay, begin print Hi and then about we multiply 3 and 4. So if my-delay were a
function, we know that this argument to it will get evaluated right away, and it
would print hi once. That's how functions work. But our my-delay macro picks up this
syntax and puts it under a lambda, makes a thunk out of it and so there's no
printing. Now we also have our old my-force function. my-force is just a
function, it's right here, it works exactly like we learned in an earlier
segment. And that we can now still use on the result of my delay, because that did
return a promise. And now we see it print out and also return the result, 12. And
because of how promises work and how my-force is implemented, we know that,
that expression is only evaluated once. That we did a set m cdr bang to change the
results, so if we force that same promise again, we get the 12 but we don't see
Printing. So those are example uses of macros you
can learn how to define in the upcoming segments. you know, and basically, it's
likely added new keywords to our language. I should mention that macros have a bad
reputation generally in computer science and software development, and frankly,
they often deserve it. macros are often overused, or they're often used in
positions where functions make a lot more sense stylistically, in terms of what
you're trying to do. And I actually do want to leave you with the message of,
when in doubt, if you're not sure a macro is useful, probably you shouldn't define
one, and probably you shouldn't use one. But if you like that version of my-delay,
where you just got to write e, and the user didn't have to write lambda
parenthesis, parenthesis e, well then you really need a macro. Because no function
in the world can have an argument that it does not evaluate. So since macros can be
used well, I hope that the optional segments coming up can help people
understand why macros are difficult to use well, and give some guidance on doing so.
And so the optional stuff ahead is that we're going to talk about how macro
systems need some basic semantics of how they deal with parentheses and variables
and things like that. We'll learn how to define macros, like the ones we just used
in this segment. We'll learn that when you're defining a macro you have to be
extra careful about which expressions evaluate where and how many times. And
then we'll see the key thing that Racket does better than most macro systems. Which
is that it actually has a reasonable semantics, when macros define local
variables, or use variables that are in scope where the macro's defined. This is
something that most languages just do, what I would say wrong, but in some sense
they're just a different semantics, and they work differently. And I'll show you
why Racket symantics, is, is a sup erior one in almost all circumstances.
