On Tue, 25 Sep 2012 16:07:51 -0400, Jonathan M Davis <jmdavisp...@gmx.com>
wrote:
On Tuesday, September 25, 2012 15:48:11 Steven Schveighoffer wrote:
On Tue, 25 Sep 2012 15:23:50 -0400, deadalnix <deadal...@gmail.com>
wrote:
> Le 25/09/2012 20:57, Maxim Fomin a écrit :
>> On Tuesday, 25 September 2012 at 17:48:46 UTC, deadalnix wrote:
>>> This is code duplication and is generally considered as a bad
>>> practice. I'm not convinced that the language should be modified to
>>> allow something that is known as bad practice.
>>>
>>> What you need here is a more robust di generator IMO.
>>
>> This is neither a code duplication (there is certain distinction
between
>> prototype and body) nor a bad practice - this is a common pattern in
C
>> and C++. It is surprising that D cannot do such a simple thing which
in
>> addition is not harmless, so there is no sense in depreciating it.
>
> This is code duplication. And this has been considered a problem in
> C/C++ for a while now.
No, it's a prototype.
Note that it's *required* if you want to hide implementation using .di
files.
There is no code involved, it's just generating a symbol reference in
the
object file.
It's still code duplication, because you've now listed the function
signature
twice. Yes, it's minimal code duplication, but it's still duplicating
code.
I misunderstood, I was thinking in terms of generated code.
But in any case, it's still not duplicated code. What you are doing is
defining an interface, then attaching the implementation of the interface
to the declaration by repeating its name.
Would you say repeating the function signature of an interface in an
implementing class is code duplication? Would you say that typing the
name of a variable that you already declared so you could access it is
code duplication?
Duplicated or not, it's still valid under the spec as far as I can tell.
It's necessary for stuff like .di files (which are code duplication by
definition, because they're duplicating a module - or at least part of
it), but
most everyone I know has thought (where it's come anyway) that
prototypes were
a _bad_ thing about C/C++.
The main reason for having prototypes in C/C++ was so you could declare a
symbol that you weren't defining yet.
In some cases, this was necessary, because C/C++ does not have forward
references. So there is indeed very little reason in D to declare a
function, then implement it in the same file.
But I think what Manu is trying to do is not exactly just "repeat the
signature", he is using the signature of the original to generate the
signature of the auto-generated function. Essentially, it's not
duplicated code on either the source or the compiled level, so disabling
the ability to declare a function and then implement it later would
prevent this possibility. I don't think it makes sense to do that.
-Steve
