It would be nice if you could add code into constructors (and destructors) with mixins. For example, you could initialize member objects/structures added by a mixin, etc.

One way to achieve this is to have 'common constructors' that are executed before the normal ones. For example:

    class Foo {
        common_this() {
            a = 1;
        }

        this() {
            b = 1;
        }
        this(int val) {
            b = val;
        }
    }

Which would be equal to:

    class Foo {
        this() {
            a = 1;
            b = 1;
        }
        this(int val) {
            a = 1;
            b = val;
        }
    }

To be useful with mixins, multiple common operators should be allowed:

    common_this() {
        a = 1;
    }
    common_this() {
        aa = 1;
    }

Would be equal to:

    common_this() {
        a = 1;
        aa = 1;
    }

Each mixin could then have its own common constructor.

Actually I think this feature would be nice to have even if not used with mixins. It would modulate constructors making them clearer and easier to maintain.

Of course, similarly there could also be polish constructors (e.g. 'polish_this()') that are called after the normal ones.


And finally, there should also be common destructors (e.g. '~common_this()', 'finish_this()', 'destroy_this()') to be used with mixins. This way each mixin could add code to the actual destructor.

On Fri, 03 Nov 2006 12:07:48 +0200, Kristian Kilpi <kjkilpi@gmail.com> wrote:
>
> ...
>

Hmm... ok, my name will now include my last name...

(Just wanted to tell you that you are dealing with the same guy here.)

Kristian Kilpi wrote:
> 
> It would be nice if you could add code into constructors (and destructors)  with mixins. For example, you could initialize member objects/structures  added by a mixin, etc.
> [snip]
> And finally, there should also be common destructors (e.g.  '~common_this()', 'finish_this()', 'destroy_this()') to be used with  mixins. This way each mixin could add code to the actual destructor.

Actually what you suggest seems to already be the case for destructors.  Don't know if it's in the spec, but I just noticed it yesterday.


template Death(int i)
{
    ~this() {
        writefln("Death says: see you! ", i);
    }
}
class DClass
{
    mixin Death!(1);
    mixin Death!(2);
    mixin Death!(3);

    ~this() {
        writefln("Class bye bye!");
    }

    mixin Death!(4);
    mixin Death!(5);
    mixin Death!(6);
}

The destructors get called in reverse order of appearance within DClass.

--bb

On Fri, 03 Nov 2006 14:33:20 +0200, Bill Baxter <wbaxter@gmail.com> wrote:

> Kristian Kilpi wrote:
>>  It would be nice if you could add code into constructors (and destructors)  with mixins. For example, you could initialize member objects/structures  added by a mixin, etc.
>> [snip]
>> And finally, there should also be common destructors (e.g.  '~common_this()', 'finish_this()', 'destroy_this()') to be used with  mixins. This way each mixin could add code to the actual destructor.
>
> Actually what you suggest seems to already be the case for destructors.   Don't know if it's in the spec, but I just noticed it yesterday.
>
>
> template Death(int i)
> {
>      ~this() {
>          writefln("Death says: see you! ", i);
>      }
> }
> class DClass
> {
>      mixin Death!(1);
>      mixin Death!(2);
>      mixin Death!(3);
>
>      ~this() {
>          writefln("Class bye bye!");
>      }
>
>      mixin Death!(4);
>      mixin Death!(5);
>      mixin Death!(6);
> }
>
> The destructors get called in reverse order of appearance within DClass.
>
> --bb

Well now, that's nice. :)

This feature is not yet documented, maybe Walter is experimenting things for future releases... Hopefully we'll have something like it for the ctors also.

Kristian Kilpi wrote:
> On Fri, 03 Nov 2006 14:33:20 +0200, Bill Baxter <wbaxter@gmail.com> wrote:
> 
>> Kristian Kilpi wrote:
>>
>>>  It would be nice if you could add code into constructors (and  destructors)  with mixins. For example, you could initialize member  objects/structures  added by a mixin, etc.
>>> [snip]
>>> And finally, there should also be common destructors (e.g.   '~common_this()', 'finish_this()', 'destroy_this()') to be used with   mixins. This way each mixin could add code to the actual destructor.
>>
>>
>> Actually what you suggest seems to already be the case for destructors.    Don't know if it's in the spec, but I just noticed it yesterday.
>>
>>
>> template Death(int i)
>> {
>>      ~this() {
>>          writefln("Death says: see you! ", i);
>>      }
>> }
>> class DClass
>> {
>>      mixin Death!(1);
>>      mixin Death!(2);
>>      mixin Death!(3);
>>
>>      ~this() {
>>          writefln("Class bye bye!");
>>      }
>>
>>      mixin Death!(4);
>>      mixin Death!(5);
>>      mixin Death!(6);
>> }
>>
>> The destructors get called in reverse order of appearance within DClass.
>>
>> --bb
> 
> 
> Well now, that's nice. :)
> 
> This feature is not yet documented, maybe Walter is experimenting things  for future releases... Hopefully we'll have something like it for the  ctors also.

I wonder if this is an accidental artifact of compiler internals?

I don't remember seeing any justifications for this behavior.

On Fri, 03 Nov 2006 18:01:16 +0200, Georg Wrede <georg.wrede@nospam.org> wrote:

> Kristian Kilpi wrote:
>> On Fri, 03 Nov 2006 14:33:20 +0200, Bill Baxter <wbaxter@gmail.com> wrote:
>>
>>> Kristian Kilpi wrote:
>>>
>>>>  It would be nice if you could add code into constructors (and  destructors)  with mixins. For example, you could initialize member  objects/structures  added by a mixin, etc.
>>>> [snip]
>>>> And finally, there should also be common destructors (e.g.   '~common_this()', 'finish_this()', 'destroy_this()') to be used with   mixins. This way each mixin could add code to the actual destructor.
>>>
>>>
>>> Actually what you suggest seems to already be the case for destructors.    Don't know if it's in the spec, but I just noticed it yesterday.
>>>
>>>
>>> template Death(int i)
>>> {
>>>      ~this() {
>>>          writefln("Death says: see you! ", i);
>>>      }
>>> }
>>> class DClass
>>> {
>>>      mixin Death!(1);
>>>      mixin Death!(2);
>>>      mixin Death!(3);
>>>
>>>      ~this() {
>>>          writefln("Class bye bye!");
>>>      }
>>>
>>>      mixin Death!(4);
>>>      mixin Death!(5);
>>>      mixin Death!(6);
>>> }
>>>
>>> The destructors get called in reverse order of appearance within DClass.
>>>
>>> --bb
>>   Well now, that's nice. :)
>>  This feature is not yet documented, maybe Walter is experimenting things  for future releases... Hopefully we'll have something like it for the  ctors also.
>
> I wonder if this is an accidental artifact of compiler internals?
>
> I don't remember seeing any justifications for this behavior.

If it is a bug, then it's a useful one.

Several times in my C++ projects I have used macros to add methods etc to classes and code to constructors (and that's even if objects are value types and structures have ctors etc in C++). It's a very annoying -- and potentially buggish -- way. An alternate way would be to write/copy the same code over and over again, but it's more error-prone, of course.

Georg Wrede wrote:
> Kristian Kilpi wrote:
>> On Fri, 03 Nov 2006 14:33:20 +0200, Bill Baxter <wbaxter@gmail.com> wrote:
>>
>>> Kristian Kilpi wrote:
>>>
>>>>  It would be nice if you could add code into constructors (and  destructors)  with mixins. For example, you could initialize member  objects/structures  added by a mixin, etc.
>>>> [snip]
>>>> And finally, there should also be common destructors (e.g.   '~common_this()', 'finish_this()', 'destroy_this()') to be used with   mixins. This way each mixin could add code to the actual destructor.
>>>
>>>
>>> Actually what you suggest seems to already be the case for destructors.    Don't know if it's in the spec, but I just noticed it yesterday.
>>>
>>>
>>> template Death(int i)
>>> {
>>>      ~this() {
>>>          writefln("Death says: see you! ", i);
>>>      }
>>> }
>>> class DClass
>>> {
>>>      mixin Death!(1);
>>>      mixin Death!(2);
>>>      mixin Death!(3);
>>>
>>>      ~this() {
>>>          writefln("Class bye bye!");
>>>      }
>>>
>>>      mixin Death!(4);
>>>      mixin Death!(5);
>>>      mixin Death!(6);
>>> }
>>>
>>> The destructors get called in reverse order of appearance within DClass.
>>>
>>> --bb
>>
>>
>> Well now, that's nice. :)
>>
>> This feature is not yet documented, maybe Walter is experimenting things  for future releases... Hopefully we'll have something like it for the  ctors also.
> 
> I wonder if this is an accidental artifact of compiler internals?
> 
> I don't remember seeing any justifications for this behavior.

It's mentioned in the changelog.

Lionello Lunesu wrote:
> Georg Wrede wrote:
> 
>> Kristian Kilpi wrote:
>>
>>> On Fri, 03 Nov 2006 14:33:20 +0200, Bill Baxter <wbaxter@gmail.com> wrote:
>>>
>>>> Kristian Kilpi wrote:
>>>>
>>>>>  It would be nice if you could add code into constructors (and  destructors)  with mixins. For example, you could initialize member  objects/structures  added by a mixin, etc.
>>>>> [snip]
>>>>> And finally, there should also be common destructors (e.g.   '~common_this()', 'finish_this()', 'destroy_this()') to be used with   mixins. This way each mixin could add code to the actual destructor.
>>>>
>>>>
>>>>
>>>> Actually what you suggest seems to already be the case for destructors.    Don't know if it's in the spec, but I just noticed it yesterday.
>>>>
>>>>
>>>> template Death(int i)
>>>> {
>>>>      ~this() {
>>>>          writefln("Death says: see you! ", i);
>>>>      }
>>>> }
>>>> class DClass
>>>> {
>>>>      mixin Death!(1);
>>>>      mixin Death!(2);
>>>>      mixin Death!(3);
>>>>
>>>>      ~this() {
>>>>          writefln("Class bye bye!");
>>>>      }
>>>>
>>>>      mixin Death!(4);
>>>>      mixin Death!(5);
>>>>      mixin Death!(6);
>>>> }
>>>>
>>>> The destructors get called in reverse order of appearance within DClass.
>>>>
>>>> --bb
>>>
>>>
>>>
>>> Well now, that's nice. :)
>>>
>>> This feature is not yet documented, maybe Walter is experimenting things  for future releases... Hopefully we'll have something like it for the  ctors also.
>>
>>
>> I wonder if this is an accidental artifact of compiler internals?
>>
>> I don't remember seeing any justifications for this behavior.
> 
> 
> It's mentioned in the changelog.

Cool!