Silly question about "_".

[marcovc]

Hi!

I always thought that we use "auto" in (standard) c++ in the following piece of code:

auto i = 3;

just because doing just

i = 3;

would be "too disruptive". But now I see that even when we are free from backward compatibility, there it is "auto" again, this time with a new symbol "_". I was just curious, why can't we get always away without specifying the type at all when we want it to be automatically inferred, on in other words, why can't we denote "auto" as ""?

[msadeqhe]

That's a good question. Actually _ is optional except for template parameters:

fnc1: (x: _) -> _ = x + 1;
fnc2: (x)           x + 1;

var1: _ = 10;
var2:   = 10;

// Type template parameter
cls1: <T: type> type = { }
cls2: <T>       type = { }

// Non-type template parameter
cls3: <T: _> type = { }

Because "type template parameters" are the default type. If we want "non-type template parameters", we have to explicitly write it.

[JohelEGP]

No, that's an assignment.
The default for parameter declarations omits : type = value.
That's why statement parameters need the :.

(x := 0) { … }

[jcanizales]

Oh we already have default argument values? I thought they were on hold pending to see if function overloading was a good enough substitute.

[JohelEGP]

Only for parameters of statements (see https://github.com/hsutter/cppfront/wiki/Design-note%3A-Defaults-are-one-way-to-say-the-same-thing).

[jcanizales]

Oh but that note shows as example:

f:(x: int = init) = { ... }

Is it an "in the works" thing? (I hope the asymmetry with parameterized statements is only temporary)

[JohelEGP]

See #75.

[SebastianTroy]

I think it would become a cause of bugs. Imagine in a new scope you want a variable with a common name like i, so you use i = 0, and it actually sets the value in an outer scope. At least with i: = 0 the cpp2 transpiler can warn about a variable name being reused, and the person maintaining the code can see that a new variable was intended, rather than have to guess that's what the author of the code meant On 12 October 2023 09:04:17 Marco Correia ***@***.***> wrote: Oh I see, it would be impossible to distinguish those two cases if we don't include the type specifier prefix ":". Thanks. — Reply to this email directly, view it on GitHub<#747 (reply in thread)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AALUZQPYSQQF5YBEMSNGWSDX66P75ANCNFSM6AAAAAA55FJV44>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[ntrel]

@msadeqhe

That's a good question. Actually _ is optional except for template parameters:

fnc1: (x: _) -> _ = { return x + 1; }
fnc2: (x)         = { return x + 1; }

Actually fnc2 is an error, you have to use = expression; to get return type inference:

fnc2: (x) = x + 1;

fnc3: (x)           x + 1;

BTW given we now have the fnc3 form, I don't see why we need the fnc2 form with implicit return. I would get rid of that and just have = statement.

[JohelEGP]

the fnc2 form with implicit return

There's no implicit return.
These are equivalent:

fnc2: (x: _) -> void = { x + 1; }
fnc2: (x)         = x + 1;

It's an error in Cpp2 because you didn't discard the value.
You get it with -Werror=unused-result -Werror=unused-value on Clang and GCC: https://cpp2.godbolt.org/z/hEMjEMz1r.
Or maybe it should be guaranteed by Cppfront regardless of Cpp1 compiler, e.g., lowered CPP2_VOID(x + 1).

[msadeqhe]

Thanks. I fixed it.

[ntrel]

@JohelEGP thanks, I see.