Constructors

[v-bulle]

Currently Carbon has only one way to construct class instances which uses braces with all the fields explicitly defined.

For example:
class Foo {
var x: i32;
var y: i32;
}

var origin: Foo = {.x = 0, .y = 0};

In particularly, this is used by factory functions:

class Foo {
var x: i32;
var y: i32;
fn CreateOrigin() -> Self {
return {.x = 0, .y = 0};
}
}

When it comes to derived class, the syntax is, for example:

class Bar extends Foo {
var z: i32;
fn CreateBarOrigin() -> Self {
return {.base = Foo.CreateOrigin(), .z = 0};
}
}

I find the keyword base a little bit confusing and, on top of that, it forbids the definition of a field named base (which is quite an usual name).

One alternative would be to instead write something like:
return {... Foo.CreateOrigin(), .z = 0};

Where the three dots means the base class.

From my point of view, having constructors (on top of field initialization) could be useful (especially when a class has a lot of fields).

class Foo {
var x: i32;
var y: i32;
constructor[me: Self](x: i32, y: i32) {
me.x = x;
me.y = y;
}
}

For a derived class we could use a C++ like syntax:
Bar.constructor[me: Self](x: i32, y: i32, z: i32)
: Foo{x, y} {
me.z = z;
}

Or a syntax which allows some computation before the base class construction:
Bar.constructor[me: Self](x: i32, y: i32, z: i32)
const new_x = x * scale;
const new_y = y * scale;
…{new_x, new_y};
me.z = z * scale;
}

Where the three dots mean access to the base class’ (here Foo) constructor.

[geoffromer]

Any keyword spelling risks colliding with identifier names, and we specifically don't want to go down the co_await road of making keywords ugly in order to avoid collisions. Sometimes a non-keyword syntax can work instead, but in this case it's hard to think of one that would be readable enough (using ... this way would be very surprising for C and C++ programmers, where that token has a very different meaning). However, we've talked about ways of working around keyword collisions when they happen, for example with some sort of "raw identifier" syntax.

See p0257 for a discussion of the problems that we're trying to avoid by not having constructors.

[v-bulle]

I understand now how three dots can be confusing.

I still find the ".base" syntax not really consistent.

Instead we could have:
return {base = Foo.CreateOrigin(), .z = 0}; // This way base is a keyword and not a special field.

return {. = Foo.CreateOrigin(), .z = 0}; // Unnamed field which can't collide with a field

return {.. = Foo.CreateOrigin(), .z = 0}; // Reminds the parent directory in linux

return {.Foo.CreateOrigin(), .z = 0}; // Not 100% sure about this one