Is it possible to have Lisp-like Macros in a language without s-expressions?
For example, why not use indentation instead of parentheses?
defmacro exists (code list):
for x in ,list:
if ,code:
return True
return False
exists(x > 10, [1 5 333]) => t
In other words, macros are awesome and you could easily put them in another language. Lisp isn't great because of macros, it's great because of how well (mind blowingly well) macros play with with all of the other parts of lisp. Macros are empowered by the rest of the langauge, and the rest of the language is empowered by macros. And this is really the theme of lisp, it's not one feature that makes the language impressive, it's how the features seem to amplify one another.
They depend on homoiconicity, which S-expressions are the mechanism for in lisp.
But as for your statement that "macros don't rely on homoiconicity", I find it hard to agree, because if that were the case, then why haven't Java or Python implemented the macro feature by now?
Copied from: https://perl6advent.wordpress.com/2012/12/23/day-23-macros/
macro checkpoint {
my $i = ++(state $n);
quasi { say "CHECKPOINT $i"; }
}
checkpoint;
for ^5 { checkpoint; }
checkpoint;
Lisp has a lot of features that other languages haven't implemented. We could spend all day asking why other languages haven't implemented them yet. And it's unfortunate, because just adding the feature for macros would allow you to add a lot of those other features. Indeed, macros are such a big deal that they are probably the sole defining reason that lispers can add features from other languages so easily.
However, we need to stop pretending that code substitution is some magical, genius feature that can only exist in the utopian environment of a common lisp system. It's a simple idea that's been used since before I was born. Macros in lisp are nice because you have so much access to the language, as well as (perhaps more so than any popular language) really smart tools for manipulating the data structure your code is written in. If you have to code code, if you have to write code that manipulates other code, it's nice if that other code is in an easy to understand data structure. And even easier if you already have a bunch of functions, classes, variables, etc given to you by the language for changing that data structure. Which lisp does, and that's what makes lisp lisp.
> However, we need to stop pretending that code substitution is some magical, genius feature that can only exist in the Utopian environment of a common lisp system.
I couldn't agree more.
In reality, lisp macros are functions that accept lists and emit lists. The difference is they operate at compile time, so they transform code.
In fact, a common macro implementation pattern is to delegate the actual work to a function that transforms lists, with the macro passing the code as a list and returning the resultant list as expanded code. I imagine this makes macros an order of magnitude easier to test.
In other languages, it's possible and can be done as in Rust etc. It's just far far more natural to do so in a homoiconic language due to the above.
If you disagree because Forth is too minimalistic, look at Factor (http://www.factorcode.org).
If with "Lisp-like macro", you mean "hygienic macros" (https://en.m.wikipedia.org/wiki/Hygienic_macro), look at Dylan (https://opendylan.org/books/drm/Macros) (which originally had a Lisp-like syntax), Julia, Perl6, or Rust.
I do not remember details of course, but those two versions were something like these:
DEFMACRO PLUS2(X,Y): BEGIN LIST('+,X,Y) END
(defmacro (plus2 x y) (list '+ x y))