verdigris

10 years ago, in another life, I was already experimenting with trying to provides feature from moc with reflections and from other macros: - https://woboq.com/blog/reflection-in-cpp-and-qt-moc.html 2014, That was based on a previous reflection proposal - https://github.com/woboq/verdigris : 2016, Replaces the moc by a set of macros. What my verdigris experience shows is that it is perfectly possible to replace the moc at the cost of slightly uglier macros. And this was using C++14. I haven't look in details at the C++26 reflection, but I'm sure it would make it easier to make these macro more pretty.

You can use Verdigris to achieve the same with Qt https://github.com/woboq/verdigris

This is overly dramatic. The "keywords" are just macros. If you don't want an additional preprocessor to generate code in a separate .cpp file from these macros, you can use https://github.com/woboq/verdigris The concurrency model, object ownership and life cycle you are mentioning are not part of C++, those are just conventions in specific C++ user groups - Qt code compiles plain and simple with pretty much every conformant C++ compiler and that makes it as much C++ as anything else.

Nope, Qt 6 still uses moc. I don't think modern C++ metaprogramming is quite capable of entirely replacing moc. The closest thing I'm aware of is [0], but it requires additional macros compared to what moc requires, and compilation speed can suffer. Chances are moc won't be dropped until full reflection lands, if ever, and even then if compilation speed is too bad I wouldn't be entirely surprised if moc remains. [0]: https://github.com/woboq/verdigris

> it's possible to do Qt without moc even in C++ with https://github.com/woboq/verdigris/, why wouldn't it be possible from D ? You're talking about an entirely different thing. While OP was referring to the current state of D's ecosystem and the impact that missing key frameworks have on hindering adoption, you're arguing about the theoretical possibility of writing a framework with a language, which really does not address OP's point.

> Honestly, the only thing lacking with D (for me) is the lack of good support from Qt (which I think is something Qt should tackle by making the moc multilingual) it's possible to do Qt without moc even in C++ with https://github.com/woboq/verdigris/, why wouldn't it be possible from D ? it should be even easier considering that D traits allow reflection of member and function names, etc.

Simply add https://github.com/woboq/verdigris so you eliminate moc and can use C++ ≥ 14.

Simply add https://github.com/woboq/verdigris so you can use C++ ≥ 14.

Simply add https://github.com/woboq/verdigris so you can use C++ ≥ 14.

A much less invasive solution to the problem: https://github.com/woboq/verdigris

> Signals and slots compile into plain C++ functions. The input language (the unnamed Qt superset of C++) has a notion of signals and slots, the output language (C++) does not have any such notion. If that was the case, gcc and clang would not be able to build Qt files. Yet the following compiles without issues : echo "#include <QObject>\nstruct foo : QObject { signals: void bar(); public slots: void blah() { } };" | g++ -std=c++11 -fPIC -I /usr/include/qt/QtCore -c -x c++ - which is all that is needed to ensure that some code is indeed 100% valid C++ code - that it is idiomatic is a wholly different question. hell, you can even generate the signals code without moc if you are ok with more macros (https://github.com/woboq/verdigris)

No. But there are alternatives to moc like: https://github.com/woboq/verdigris .

> Qt's approach requires a separate compilation pass woith a Qt-specific tool named "moc" which declares a bunch of info in the signal class that's necessary for the slot implementation. If you are willing to accept uglier macros, you can have QObject-compatible signals / slots in pure C++ without any kind of specific tool : https://github.com/woboq/verdigris Also, Qt's approach is thread-safe (if you call a signal in a thread A on an object attached to a thread B, the slot will be executed in thread B) since it is tied to Qt's event loop.