I think Scheme doesn't have the all-powerful Macros, so would one be missing out on all the LISP goodness for choosing Scheme?
How usable are Macros, anyway? Does their use tend to produce readable code?
Is Scheme as good as Common Lisp?
1–10 of 25 posts
Re: Is Scheme as good as Common Lisp?
#2Yes, but both are widely considered inferior to Visual Forth ++.
Re: Is Scheme as good as Common Lisp?
#3R5RS hygienic macros qualify as LISP goodness, but a lot of Scheme implementations also implement defmacro (like CL) and/or syntax-case.
Use of macros makes the code reflect the programmer's thinking about the problem domain. Whether this is readable or not depends on the programmer.
Re: Is Scheme as good as Common Lisp?
#4Scheme has a way of defining macros that's supposed to be better than old-fashioned defmacro. These "hygienic macros" seemed to a lot of people (though not me) to be a good idea when they were invented. They got into the Scheme standard then. I think people don't like them so much now, but once something gets into a standard it's impossible to get it out.
However (a) all the Scheme implementations I know of have implemented classic defmacro macros as well, and (b) if one hadn't, you could easily write it yourself. So in practice there's not much of a decision to make.
The Arc implementation you're using to read this is written on top of Scheme. Currently Mzscheme.
Re: Is Scheme as good as Common Lisp?
#5Scheme has a way of defining macros that's supposed to be better than old-fashioned defmacro. These "hygienic macros" seemed to a lot of people (though not me) to be a good idea when they were invented. They got into the Scheme standard then. I think people don't like them so much now, but once something gets into a standard it's impossible to get it out. However (a) all the Scheme implementations I know of have impl…
Thanks for the info! I learned Scheme with a rather obscure implementation (LMU Scheme, from my university), so I wasn't aware of the Macro capabilities of Scheme. Edit: I just checked, LMU Scheme is based on R4RS and indeed has no Macros.
Re: Is Scheme as good as Common Lisp?
#6Scheme has a way of defining macros that's supposed to be better than old-fashioned defmacro. These "hygienic macros" seemed to a lot of people (though not me) to be a good idea when they were invented. They got into the Scheme standard then. I think people don't like them so much now, but once something gets into a standard it's impossible to get it out. However (a) all the Scheme implementations I know of have impl…
Hygienic macros do seem to be a good idea: "Hygienic macros are macros whose expansion is guaranteed not to cause collisions with existing symbol definitions." (from Wikipedia, http://en.wikipedia.org/wiki/Hygienic_macro)
What are the disadvantages? Is there any reason to dislike defining syntax rules?
Re: Is Scheme as good as Common Lisp?
#7Macros produce kickass code: http://neverfriday.com/blog/?p=10#more-10
If I didn't create a string-case= macro, I would have to write the final expression over and over again. With multiple string-case matches I would have to write string=? many many times:
(cond ((or (string=? "hello" my-string)
(string=? "world" my-string))
(print "match")))
(string-case= my-string
(("hello" "world")
(print "match")))
edit: formatting ftw.
Re: Is Scheme as good as Common Lisp?
#8Scheme has a way of defining macros that's supposed to be better than old-fashioned defmacro. These "hygienic macros" seemed to a lot of people (though not me) to be a good idea when they were invented. They got into the Scheme standard then. I think people don't like them so much now, but once something gets into a standard it's impossible to get it out. However (a) all the Scheme implementations I know of have impl…
Hygienic macros do seem to be a good idea: "Hygienic macros are macros whose expansion is guaranteed not to cause collisions with existing symbol definitions." (from Wikipedia, http://en.wikipedia.org/wiki/Hygienic_macro ) What are the disadvantages? Is there any reason to dislike defining syntax rules?
One reason I've heard is that sometimes you actually want those collisions (I haven't come across a good example though - anyone know of one?).
For me the reason is just that defmacro is easier to read.
Re: Is Scheme as good as Common Lisp?
#9Earlier quoted context omitted.
Hygienic macros do seem to be a good idea: "Hygienic macros are macros whose expansion is guaranteed not to cause collisions with existing symbol definitions." (from Wikipedia, http://en.wikipedia.org/wiki/Hygienic_macro ) What are the disadvantages? Is there any reason to dislike defining syntax rules?
One reason I've heard is that sometimes you actually want those collisions (I haven't come across a good example though - anyone know of one?). For me the reason is just that defmacro is easier to read.
here's one:
(defmacro aif (test then &optional else)
`(let ((it ,test))
(if it ,then ,else)))Re: Is Scheme as good as Common Lisp?
#10Earlier quoted context omitted.
Hygienic macros do seem to be a good idea: "Hygienic macros are macros whose expansion is guaranteed not to cause collisions with existing symbol definitions." (from Wikipedia, http://en.wikipedia.org/wiki/Hygienic_macro ) What are the disadvantages? Is there any reason to dislike defining syntax rules?
One reason I've heard is that sometimes you actually want those collisions (I haven't come across a good example though - anyone know of one?). For me the reason is just that defmacro is easier to read.
One example is the magical introduction of special variables. Here's "aif", implemented in PLT Scheme:
(require (lib "defmacro.ss"))
(define-macro (aif a b c)
`(let ((it ,a))
(if it ,b ,c)))
(aif (* 10 10) (+ it 1) 'oops) ==> 101
If you're thinking, "whatever, I don't need that" you are wrong. :) Somehow this turns into the most wonderful little line-saver. At my last company, we used it all over the place.