Compile time support for Aspect-oriented programming

Thanks for taking the time respond.

I didn’t know Rust macro system before and it seems really interesting and I would love for Swift to have something as powerful and maybe we can build this feature on it but I still think that it will be better build into the language.

This feature describes here is basically Aspect-oriented programming but without the dynamism and its goal is to give you tools to better organize some part of your code and the wiki of AOP will explain this way better than me 😅.

Maybe I should rename the feature to something like AOP without the dynamic part it will convey more of what it can do?

From all your comment I understand that I’m terrible at explaining it and I’m sorry, but it’s possible with the feature that I propose here.

I think I should rewrote the pitch.

IMO, and from what many people here also share, is that this is most definitely a functionality that is desirable. The issue that most people raise, and I tend to agree, is that this functionality should derive from a powerful macro system that might encompass things like this, as well as property behaviors.

So rather than rewriting the pitch, I think it might be better to move this down a level, back to the discussion phase. There we can start hashing out if useful function decorators would be possible in Swift and how they should look like. This discussion will also allow us to settle on a possible syntax/approach to how they might look, or defer the feature discussion entirely until the time comes to really devote time to discussing a true macro system.

tl;dr: People think this functionality is desirable, but we should move back to the exploration phase rather than pitching something

1 Like

You are right @nuclearace we should have an open discussion about the macro system we expect, but I don’t think I can drive this kind of discussion I don’t know enough about macro or about what a desirable macro system could be.