• onlinepersona@programming.dev
    link
    fedilink
    English
    arrow-up
    0
    ·
    edit-2
    6 months ago

    I’m not getting it. What’s the point? It seems very much like a cpp-ism where you can put const in so many places.

    const int n2 = 0;    // const object
    int const n3 = 0;    // const object (same as n2)
    // https://learn.microsoft.com/en-us/cpp/cpp/const-and-volatile-pointers?view=msvc-170
    const char *cpch;  // const variable cannot point to another pointer
    char * const pchc; // value of pointer is constant
    
    int f() const; // members cannot be modified in this, only read
    std::string const f(); // returns a constant
    

    Then there are constant expressions.

    Can anybody look at that and tell me it’s readable with a straight face? I hope they don’t start adding all this stuff to rust.

    Anti Commercial-AI license

    • Alex@programming.dev
      link
      fedilink
      arrow-up
      3
      ·
      6 months ago

      Nope. This little neat feature mainly is just necessary part of bigger one - const-generics with const bounds.

    • Miaou@jlai.lu
      link
      fedilink
      arrow-up
      2
      ·
      6 months ago

      It can be used for producing const values in arbitrary context. Can basically be swapped for c++'s constexpr.

      C++'s const does not exist in rust (values are const by default).

  • sugar_in_your_tea@sh.itjust.works
    link
    fedilink
    arrow-up
    0
    ·
    6 months ago

    Huh, this is awesome! From the link, this now works:

    let v: Vec<i32> = const { Vec::new() };
    

    I’m going to have to play with this to see how far it goes.

      • sugar_in_your_tea@sh.itjust.works
        link
        fedilink
        arrow-up
        1
        ·
        edit-2
        6 months ago

        Ah, apparently for now you’re not allowed to allocate. But vec::new_in(allocator) looks interesting. This works in nightly today:

        #![feature(allocator_api)]
        
        use std::alloc::Global;
        
        fn main() {
            const MY_VEC: Vec<i32> = const {
                Vec::new_in(Global)
            };
            println!("{:?}", MY_VEC);
        }
        

        Maybe at some point I can append to it at compile time too. I’d love to be able to put a const {} and have allocations that resolve down to a 'static, and this seems to be a step toward that.

        I guess I’m just excited that Vec::new() is the example they picked, since the next obvious question is, “can I push?”