Hi,

Motivation:

std::initializer_list is known to have two issues:

1) it does not support move only types,

2) constructor that takes std::initializer_list breaks consistency between direct- and list-initialization.

Proposed solutions:

For problem 1) for all STL containers introduce additional constructor overloads as below

#include <cstddef>

constexpr struct from_range_t{} from_range;

template <typename T>
struct vector
{
    template <std::size_t N>
    vector(from_range_t, T (&&arr)[N]) {}

    template <std::size_t N>
    vector(from_range_t, const T (&arr)[N]) {}
};

template <typename T, std::size_t N>
vector(const T (&)[N]) -> vector<T>;

int main()
{
    // today
    using Arr = int[];
    vector<int> v1 = {from_range, Arr{1, 2u, 3}};

    // proposed
    vector<int> v2 = {from_range, {1, 2u, 3}};
}

https://godbolt.org/z/doMavhhvd

Alternatively we could change the core language so that when default template argument is T[], then template parameter is deduced as array of known size:

#include <cstddef>
#include <type_traits>

constexpr struct from_range_t{} from_range;

template <typename T>
struct vector
{
    template <typename Range = T[]>
    vector(from_range_t, Range&& r)
    {
        // Range is int[] today
        static_assert(std::is_same_v<Range, int[3]>);
    }
};

template <typename T, std::size_t N>
vector(const T (&)[N]) -> vector<T>;

int main()
{
    // today
    using Arr = int[];
    vector<int> v1 = {from_range, Arr{1, 2u, 3}};

    // proposed
    vector<int> v2 = {from_range, {1, 2u, 3}};
}

For problem 2) deprecate the behaviour where list-initialization invokes a constructor with a std::initializer_list parameter, so people migrate to new constructors from 1)

When std::initializer_list will be eventually removed we will get some more consistency in initialization:

- T(a, b, c) and T{a, b, c} will always choose the same constructors.

Regards,

Maciej Cencora