Mirror of forum.nim-lang.org

7654 :: Macros and Syntax

• buster_blue (orginal) [2021-03-18T01:30:50+01:00] view original

  I read on the Nim website that macros have a limitation where they can't change the syntax of the language. I had 3 quick questions about this that I couldn't find answers to in the documentation after searching:

  1. Is this limitation on purpose as a design choice, or is it a compromise or compiler limitation or something like that?
  2. If it is on purpose, what issues are thought to arise out of allowing macros to change syntax, that would outweigh disallowing this for users that might need it, or where it might make code neater as long as the user has proper discipline?
  3. Does this limitation result in any practical decrease in the power of macros? What I mean by this is: Are there useful kinds of things that could have been done with macros, that can't because they would require syntax changes to work in order to work correctly, or does this limitation only affect the way macros look (e.g. having a use a function instead of an operator, or something like that)

  I'm kind of a beginner programmer, so if this stuff is actually common knowledge (especially the third question) my bad. I didn't find the answers anywhere I looked.

---

• ElegantBeef (orginal) [2021-03-18T01:36:10+01:00] view original

  Well because the syntax cannot be changed it just means you may have to find a more unique method to implement the macro. For instance pattern matching has been added to Nim though macros, you can see some of the developers solutions to get around the "unchanged syntax" := for instance for unpacking objects/arrays.

---

• xigoi (orginal) [2021-03-18T07:23:41+01:00] view original

  It's so that parsing can be done before everything else, instead of having to mix it with evaluation like in C++ (which doesn't even have macros, aside from the preprocessor, but as a consequence of weird syntax choices, parsing it is undecidable!).

  It's actually a good thing, since it makes macros much easier to write (you don't need to parse the syntax yourself like in Rust) and easier to use (you can apply what you know about Nim syntax, such as being able to write foo bar, baz instead of foo(bar, baz). And Nim's syntax is very flexible, so you can do many things with it, as long as they vaguely look like Nim.

  One of the current limitations is that you can't create custom type definitions (e.g. if you want to add true sum types, you can't make it type Foo = sum, but it will have to be sumType foo:, which creates an inconsistency). I think the syntax could be made more flexible in this regard, but definitely not by allowing macros to be passed arbitrary text. And as you mention, it doesn't decrease the power of macros.

---