how to make container like std::array in cpp2 with additional operations? since cpp2 doesn't support raw array ?

[jituderaps]

problem link: https://cpp2.godbolt.org/z/rvnqnszhd

array: <T, N: int> type = {
    elem: std::array<T, N>;

    operator=: (out this, ist: std::initializer_list<T>) = {
        std::copy(ist.begin(), ist.end(), elem.begin());
    }

    operator[]: (this, i: int) -> forward T = elem[i];
    ssize     : (this) = N; 
}

main: () = {
    arr: array<int, 5> = (4, 5, 6);
}

[JohelEGP]

Why not use std::array?
You could write non-member functions,
and call it with member syntax thanks to UFCS.

Here's the code in CE: https://cpp2.godbolt.org/z/T9Psq1dhc.

That errors with:

<source>...

example.cpp2(5,9): error: in operator=, expected 'elem = ...' initialization statement (because type scope object 'elem' does not have a default initializer)
example.cpp2(2,5): error: see declaration for 'elem' here
example.cpp2(5,9): error: an operator= body must start with a series of 'member = value;' initialization statements for each of the type-scope objects in the same order they are declared, or the member must have a default initializer (in type 'array')
example.cpp2(5,9): error: in operator=, expected 'elem = ...' initialization statement (because type scope object 'elem' does not have a default initializer)
example.cpp2(2,5): error: see declaration for 'elem' here
example.cpp2(5,9): error: an operator= body must start with a series of 'member = value;' initialization statements for each of the type-scope objects in the same order they are declared, or the member must have a default initializer (in type 'array')

Compiler returned: 1

From https://github.com/hsutter/cppfront/wiki/Cpp2:-operator=,-this-&-that#operator-always-defaults-to-memberwise:

operator= always defaults to memberwise semantics. The body of the operator must begin with a series of member = value; statements, one for each of the type's data members in order. If the body skips a member, the member's default initializer is used.

That seems good to me.
If ist.size() is greater than N, you would have a bounds error.

[jituderaps]

yes i could, but i just want to make a container (that uses static and stack memory) and initializes it with std::initializer_list, can we do this in cpp2 ?

[jituderaps]

like how to initializes elem member in a array type's constructor in above problem ?

[JohelEGP]

Assign to the std::array object like you do to arr in main.
elem = (ist.begin()[0], ist.begin()[1], ist.begin()[2]).
But N is unknown, and the only alternative to keep the std::copy is to first default-initialize elem with elem = ();.

You could also make it a @struct: https://cpp2.godbolt.org/z/449xEYr9e.

[jcanizales]

Can std::array be written in Cpp2? One of the strengths of C++ is it's a good language for writing libraries, including its own standard library. (One of the strengths I see in Cpp2 is its ability to write, via compile-time inspection and codegen, even more of the C++ standard library than can be written in C++ alone.)

[jituderaps]

IMO, it would be better if cpp2 allow raw array so that we can write efficient libraries in it.

[msadeqhe]

Raw arrays in Cpp1 are pointers under the hood:

x[1] == *(&x + 1)

In Cpp2, it would be:

(x& + 1)*

[AbhinavK00]

I would say instead of allowing c arrays, there should be improvement over std::arrays. Make them easier to use, adddress their weak points etc.

[JohelEGP]

IMO, it would be better if cpp2 allow raw array so that we can write efficient libraries in it.

You can (https://cpp2.godbolt.org/z/vrKjraPs6):

template <class T, std::size_t N> using c_array = T[N];

main: () = {
    arr: c_array<int, 5> = (4, 5, 6);
}

[hsutter]

My intent was that we didn't need raw C-style arrays because std::array is already as efficient, and is safer because it knows its bounds + doesn't decay to an bounded pointer, and has conveniences like iterators if you want them, etc.

Are there use cases where a std::array is not as efficient, or as easy to use in safe ways (no pointer decay examples! :)) than a raw C-style array?

[jituderaps]

no there are no such cases, but it's negligible efficient for writing libraries than std::array.
For example: assembly for same source :
https://godbolt.org/z/EWKEscbGY
case 1:c arrays :

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-8], 3
        mov     DWORD PTR [rbp-4], 4
        mov     eax, DWORD PTR [rbp-8]
        mov     esi, eax
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        mov     eax, 0
        leave
        ret

case 2: std::array:

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-8], 3
        mov     DWORD PTR [rbp-4], 4
        lea     rax, [rbp-8]
        mov     esi, 0
        mov     rdi, rax
        call    std::array<int, 2ul>::operator[](unsigned long)
        mov     eax, DWORD PTR [rax]
        mov     esi, eax
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        mov     eax, 0
        leave
        ret

[JohelEGP]

Sounds like "Lightning Talk: C++ Debug Performance is Improving: What Now? - Vittorio Romeo - CppCon 2022".
Vittorio Romeo is our champion here.

[gregmarr]

You're building without optimization. With -O2, you get the exact same code for both cases.

        sub     rsp, 8
        mov     esi, 3
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        xor     eax, eax
        add     rsp, 8
        ret