Struct assignment/init

[bvdberg]

Currently the pattern most often used in C2 to pass a struct by value is:

Point p;
p.init(1, 2);
calc(p);

or alternatively:

Point p = Point.init(1, 2);  // without module prefix
draw.Point p = draw.Point.init(1, 2); // with module prefix

More recent versions of C allow:
calc((Point){ 1, 2 });

Having something like this would allow for more concise code. My idea is to toy with some syntax proposals first, before implementing it.
There are some different use-cases to handle then:

initialization

Point p = { 1, 2 }   // already works
draw.Point p = .init(1, 2)  // .init is short for draw.Point.init then. Only usable during initialization

assignment/param/return

p = { 1, 2 }   // the type would have to be derived
p = (Point) { 1, 2 }
return { 1, 2 }
call( { 1, 2 }, .. );

There are some restrictions:

• this would/should never work on pointer types, only on value type
• also (since no poniter), no passing CallExpr when Expr is expected (so 'sub-classes')

[lerno]

C3 already has type inference for { ... } everywhere, so you can do foo({1, 2}) if foo takes a Point. This works fine for C3. The .init pattern is something I've bumped into a lot of times. People really like the having the two step though. One thing I did was to let init return the pointer to the thing initialized. This allowed temps to be used in this pattern:

Point* p = (Point){}.init(1, 2);

Not a beauty, but that's where it's currently at. Other experiments didn't pan out so far.

[chqrlie]

For the .init() pattern, I propose to invoke constructors as part of the declaration:

Point p.init(1, 2);  // trivial example for which `Point p = { 1, 2 };` is simpler alternative.
ParserContext p.init();  // see this as an explicit call to a default constructor that does non-trivial initialization.

I really dont like the 2 step ParserContext p; p.init(); because I like to see automatic objects be explicitly uninitialized at the point of definition. This might not be an issue in C3 as zero initialization is the default (IIRC).
The problem with Point* p = (Point){}.init(1, 2); is the lifetime of the (Point){} part. This construction is a compound literal whose lifetime is the scope where it appears, semantically identical to Point point.init(1, 2); Point *p = &point; yet the fact that the actual object is not named might let the programmer make invalid assumptions about its lifetime, as if it was allocated from the heap.
Note that C allows this too: `Point *p = &(Point){};

[lerno]

This construction is a compound literal whose lifetime is the scope where it appears

In C3 it's different: the lifetime of the memory is that of the function. For that reason this is fairly safe.

Some examples here: https://c3-lang.org/language-fundamentals/expressions/#compound-literals

[chqrlie]

Currently the pattern most often used in C2 to pass a struct by value is:

Point p;
p.init(1, 2);
calc(p);

Yes, I especially dont like the first line that defines an object with any initialization.

or alternatively:

Point p = Point.init(1, 2);  // without module prefix
draw.Point p = draw.Point.init(1, 2); // with module prefix

If Point.init is defined as taking an initial Point* argument to be initialized, the above does not work, so a different name is advisable such as create. Also I dont like the redundant type name and the assignment that looks like an extra copying step.

More recent versions of C allow: calc((Point){ 1, 2 });

Yes these are called compound literals

Having something like this would allow for more concise code. My idea is to toy with some syntax proposals first, before implementing it. There are some different use-cases to handle then:

initialization

Point p = { 1, 2 }   // already works
draw.Point p = .init(1, 2)  // .init is short for draw.Point.init then. Only usable during initialization

I dont like the second one, I would prefer this alternative if p is used further down:

draw.Point p.init(1, 2);

assignment/param/return

p = { 1, 2 }   // the type would have to be derived
p = (Point) { 1, 2 }
return { 1, 2 }
call( { 1, 2 }, .. );

All of these are good, and this one too: call( (Point){ 1, 2 }, ... );
The pattern allows for a named optional function arguments:

draw_circle({ .radius: 20, .thickness: 1 })  // other properties initialized to 0

There are some restrictions:

• this would/should never work on pointer types, only on value type

Taking the address of a compound literal is actually allowed in C so ((Point){1, 2}).draw() is possible if draw takes a pointer.

• also (since no pointer), no passing CallExpr when Expr is expected (so 'sub-classes')

Passing objects where pointers are expected is not allowed, but passing a pointer to a derived object should be allowed (implicit cast to base class), whether the object is defined as a compound literal or not.

[bvdberg]

I think there are 2 different uses, one is initialization by explicit members

Point p = { .x=1, .y=2 }

The other is using a function, hiding specifics/complexity:

Point p = Point.init(1, 2);

For more complex structs, the 2nd option would be better, the shorthand notation is more used for tuples and such.

Your option for init-by-function:

draw.Point p.init(1, 2);

might not be that hard to parse. This could of course be used as param/return as:

call( Point.init(1, 2) );
return Point.init(1, 2);

it would have to be defined as a static-type-function then. The init name would be nothing special, so not a default constructor, just some type-function you define yourself