Can D be cute? (Qt)

[Jacob Carlborg]

On 5/8/10 14:01, Justin Johansson wrote:
> bearophile wrote:
>> Justin Johansson:
>>> Whilst QtD looks like a cool project, my question was really about
>>> whether D could achieve the same sorts of things that Qt does with
>>> its meta-object compiler.
>>>
>>> In other words, and calling a spade a spade, Qt is a "hack" to make
>>> C++ more pleasant for GUI. Would it be possible for D to achieve
>>> natively the same sorts that Qt does via preprocessing to C++.
>>
>> I suggest you to explain what such things are, and to give some
>> examples too.
>>
>> Bye,
>> bearophile
>
> Okay, perhaps not everybody here is across Qt.
>
> Programming in Qt is almost C++ bu not exactly C++ as Qt uses a
> preprocessor to translate "enhanced C++" into "vanilla C++".
>
> Here is an example that demonstrates that "Qt C++" is not "vanilla C++".
>
> In Qt, one adorns class declarations with things that are not valid C++.
>
> So in a class declaration you can say
>
> class MyWidget
> {
> public:
> // regular C++ stuff, attributes and methods
>
> public slots:
> // method declarations for intercepting event signals
> };
>
> You will observe that "public slots" is not valid C++. Qt's meta-object
> compiler does a preprocessing of the MyWidget class so that methods
> declared under the "public slots:" scope are subject to some kind of
> reflection or introspection that enables events (signals) to be delegate
> to the respective methods.
>
> In doing so, according to my naive understanding, the Qt MOC
> (meta-object compiler) compiles the MyWidget class retaining knowledge
> of compile time analysis of the MyWidget class methods which are
> designated as slots.
>
> So this is some kind of black magic that the MOC does to Qt source code
> in order to make event routing easier. The concepts of reflection come
> to mind here. In a way the MOC processor must be keeping a lot of the
> static analysis of classes around in similar fashion that Java does.
>
> Accordingly it is fair to ask why does Qt do this? Obviously Qt
> designers do not feel that vanilla C++ is adequate for cutting GUI apps
> which is why they resort to a preprocessor.
>
> Now I was thinking about why is C++ deficient for Qt to go to such
> resorts. And if vanilla C++ is deficient for GUI programming, and given
> that D is viewed by many as a "better C++", then can D do natively what
> Qt has to do with a preprocessor?
>
> I'm not an expert on Qt or its MOC (only 2 weeks into it). Perhaps
> others on this NG might cotton on to what I'm trying to express and
> chime in.
>
> Does the simple example above help explain what I'm on about?
>
> Cheers
>
> Justin Johanssom

I've read the two links bearophile posted and I think that Qt signals 
and slots look similar to C# events. This can easily be implemented 
using delegates. Basically create a new template type (a struct for 
example) called Event. Event contains a data structure (a linked list 
for example) of delegates. Then you have a function that adds new 
delegates to the data structure and finally a function that calls all 
the delegates in the data structure.

This code is basically the same thing as the Counter example on Qt site.

class Counter
{
	int value_;
	Event!(void, int) valueChanged;

	void value (int value)
	{
		if (value != value_)
		{
			value_ = value;
			valueChanged(value);
		}
	}

	int value ()
	{
		return value_;
	}
}

auto a = new Counter;
auto b = new Counter;

a.valueChanged += &b.value; // I'm hoping this will choose the right 
method based on the signature that is needed

a.value = 12;
b.value = 48;

Am I missing something? This seems pretty simple. If some additional 
support is needed there is always compile time reflection in the form of 
__traits: http://www.digitalmars.com/d/2.0/traits.html and runtime 
reflection in the form of flectioned: 
http://www.dsource.org/projects/flectioned

/Jacob Carlborg