[SUGGESTION] Confusing std::vector ctor calls in Cpp1 and Cpp2

[wolfseifert]

In Cpp1 we have the confusing fact that

#include <vector>
using namespace ::std;
int main() {
  auto a = vector<int>{5, 1}; // vector of five and one
  auto b = vector<int>(5, 1); // vector of five ones
}

Experimenting with (pure) Cpp2 I got a similar case

main: () -> int = {
  a: std::vector<int> = (5, 1); // vector of five and one
  b := std::vector<int>(5, 1); // vector of five ones
}

This becomes clear when looking at the tanspiled code

  std::vector<int> a { 5, 1 };  // vector of five and one
  auto b { std::vector<int>(5, 1) }; // vector of five ones

For me the Cpp2 case looks even more confusing (than the Cpp1 case), because both ctor calls use parenthesis.

[MichaelCook]

Perhaps another way to state this issue is: Should cpp2 do fine-grained removal/repair of unfortunate cpp1 API choices?

[robertshepherdcpp]

What about if we had a literal for the size, like _s so then we could just define the vector like:

a: std::vector<int> = (5, 1_s);  // a vector of 5 ones
b: std::vector<int> = (5, 1);     // a vector of 5 and 1

and then we could do it like this:

  b := std::vector<int>(5, 1_s); // vector of five ones

[JohelEGP]

How would you combine that with existing suffixes like ULL?

[filipsajdak]

Soon you will be able to write:

a: std::vector<int> = (5, 1 as std::size_t);

[robertshepherdcpp]

@filipsajdak Yes, thats good. Would an overload for a std::size_t at the end of the vector be possible?

[fpelliccioni]

@fpelliccioni Yes, thats good. Would an overload for a std::size_t at the end of the vector be possible?

I think you confused me with @filipsajdak

[JohelEGP]

a: std::vector<int> = (5, 1 as std::size_t);

What about

  auto a = vector<std::size_t>{5z, 1z}; // vector of five and one
  auto b = vector<std::size_t>(5z, 1z); // vector of five ones

[filipsajdak]

@JohelEGP cheater. 🙂

I agree that there is an issue. I am just trying to advertise the cpp2 casting feature.

What we want to achieve is unambiguous syntax. The spotted issue sure will need some reasonable solution.

[switch-blade-stuff]

IMO this would be fairly difficult to solve while keeping full compatibility with Cpp1, the issue is that in C++, the aggregate (i.e. {}) constructor favors initializer lists, while the "classic" parentheses never generate initializer lists.

So, this would either require a change in constructors of std::vector (and other containers too) to outright remove the size & value constructor, or use some kind of tag like with std::in_place_t to disambiguate overloads; or to forego the initializer-list/aggregate constructor form in Cpp2, which would prevent the ambiguity, but also disable initializer lists.

[switch-blade-stuff]

Honestly, it would be easier if C++ just left {} for initializer lists, and only use () for constructors. That way there would be no ambiguity, if you saw std::vector v = {0, 1}, you'd know it is definitely an initializer list, and the vector contains 0 and 1, instead of 1 zero.

[marioarbras]

Honestly, it would be easier if C++ just left {} for initializer lists, and only use () for constructors. That way there would be no ambiguity, if you saw std::vector v = {0, 1}, you'd know it is definitely an initializer list, and the vector contains 0 and 1, instead of 1 zero.

This would be really nice. An alternative idea could be to use an explicit cast for initializer lists.

v: std::vector = (5, 1) as std::initializer_list;

[robertshepherdcpp]

@marioarbras Or we could have it the other way round, depending on which is more common: initializing a vector with a std::initializer_list like:

  a: std::vector<int> = (5, 1); // vector of five and one

or initializing it with a certain amount of elements like:

  b := std::vector<int>(5, 1); // vector of five ones

Which would be the more common usage? Personally I use the initializer list more.

[hsutter]

Yes, fixing that problem is on my list to address as follows (I just haven't implemented it yet):

v1: vector<int> = (5, 1);   // size == 5, same as "= ((1, 1, 1, 1, 1))"
v2: vector<int> = ((5, 1)); // size == 2

The idea is that the parens in v2's initializer make it explicit that we are constructing with a single argument that is a list. (Do you "see" it visually, that the outer parens now clearly contain only a single thing? I think it's visually clear, but I'm curious to learn whether others will see it that way too.)

[switch-blade-stuff]

v: std::vector = (5, 1) as std::initializer_list;

Honestly, to me that looks just slightly better than manual insertion 😅

I suppose we could just explicitly use braces for initializer lists only, where if {stuff} is encountered in a constructor it would be replaced by ({stuff}), forcing the initializer-list overload.

Then again, this would fall flat for aggregate types such as std::array, as well as the "classic" C-style arrays that do not use std::initializer_list.