• Maxim Fomin (35/35) Sep 17 2012 I consider current struct creation one of the confusing parts of
• Don Clugston (13/45) Sep 17 2012 There is also 4) struct static initializers, which have their own

"Maxim Fomin" <maxim maxim-fomin.ru> writes:

I consider current struct creation one of the confusing parts of 
the language (may be the most), due to set of incompatible 
creation semantics masked by same syntax, complicated by couple 
of semi-bugs (7210, 1310, 4053) and naive default arguments 
embedding into the language(3438).

Current creation rules look as follows 
(http://dpaste.dzfl.pl/a4344ad0):
1) if a struct object declaration has no initializer, its members 
are default initialized to either explicit initializer in struct 
declaration or type default initializer (note: actually, there 
are no implicit struct constructors). If it has void initializer, 
it contains garbage
2) otherwise, if it has initialization form S() than:
a) if opCall member is present, it is called (must have no 
arguments)
b) otherwise, initialization proceed according to 1)
3) otherwise, if it has initialization form S(T1 arg1, ...), than:
a) if opCall member is present, it is called (its parameters must 
be consistent with arguments)
b) otherwise, if at least one ctor exists, it is called (and 
again, its parameters must be consistent with arguments)
c) otherwise, this initialization form is called struct literal 
and struct members are initialized to arguments in accordance 
with their order in struct declaration

This means that if you have S(), or S(x, y, x) - it is impossible 
to know without looking into struct definition what is going on: 
a function call (constructor or opCall) or just initialization. 
If naive default argument treatment is considered, I may add that 
there is no sense of setting default argument to one-argument 
struct constructor, since S()-like expression would call 
something else (3438). By the way, .init property may be hijacked 
(good news is that it doesn't affect default initializer).

Basically, the question is, is it considered to be good, well 
designed feature or not. And if not, would it be changed at some 
time? What was original design of structures in D?

Don Clugston <dac nospam.com> writes:

On 17/09/12 20:47, Maxim Fomin wrote:
 I consider current struct creation one of the confusing parts of the
 language (may be the most), due to set of incompatible creation
 semantics masked by same syntax, complicated by couple of semi-bugs
 (7210, 1310, 4053) and naive default arguments embedding into the
 language(3438).

 Current creation rules look as follows (http://dpaste.dzfl.pl/a4344ad0):
 1) if a struct object declaration has no initializer, its members are
 default initialized to either explicit initializer in struct declaration
 or type default initializer (note: actually, there are no implicit
 struct constructors). If it has void initializer, it contains garbage
 2) otherwise, if it has initialization form S() than:
 a) if opCall member is present, it is called (must have no arguments)
 b) otherwise, initialization proceed according to 1)
 3) otherwise, if it has initialization form S(T1 arg1, ...), than:
 a) if opCall member is present, it is called (its parameters must be
 consistent with arguments)
 b) otherwise, if at least one ctor exists, it is called (and again, its
 parameters must be consistent with arguments)
 c) otherwise, this initialization form is called struct literal and
 struct members are initialized to arguments in accordance with their
 order in struct declaration

There is also 4) struct static initializers, which have their own 
complicated set of rules.

 This means that if you have S(), or S(x, y, x) - it is impossible to
 know without looking into struct definition what is going on: a function
 call (constructor or opCall) or just initialization. If naive default
 argument treatment is considered, I may add that there is no sense of
 setting default argument to one-argument struct constructor, since
 S()-like expression would call something else (3438). By the way, .init
 property may be hijacked (good news is that it doesn't affect default
 initializer).

 Basically, the question is, is it considered to be good, well designed
 feature or not. And if not, would it be changed at some time? What was
 original design of structures in D?

Struct constructors and struct literals are late additions. opCall was, 
I think, a workaround for the lack of struct constructors.

There's a comment in the source code:
  ***************************************
   * This works by transforming a struct initializer into
   * a struct literal. In the future, the two should be the
   * same thing.
   */
  Expression *StructInitializer::toExpression()

That's the only plan I've heard of.