Stabilise inline_const by nbdd0121 · Pull Request #104087 · rust-lang/rust
github.com
Stabilisation Report Summary This PR will stabilise inline_const feature in expression position. inline_const_pat is still unstable and will not be stabilised. The feature will allow code like this...
  • kevincox@lemmy.ml
    6·
    1 year ago

    This is a nice small feature. I’m curious about the commit description:

    foo(const { 1 + 1 })

    which is roughly desugared into

    struct Foo;
impl Foo {
    const FOO: i32 = 1 + 1;
}
foo(Foo::FOO)

    I would have expected it to desugar to something like:

    foo({
  const TMP: i32 = 1 + 1;
  TMP
})

    But I can’t seem an explanation why the struct with impl is used. I wonder if it has something to do with propagating generics.

    • 0v0@sopuli.xyz
      9·
      1 year ago

      It’s because it has to work in pattern contexts as well, which are not expressions.

        • 0v0@sopuli.xyz
          9·
          1 year ago
          fn foo(x: i32) {
    match x {
        const { 3.pow(3) } => println!("three cubed"),
        _ => {}
    }
}

          But it looks like inline_const_pat is still unstable, only inline_const in expression position is now stabilized.

    • Giooschi@lemmy.worldEnglish
      7·
      1 year ago

      They tested the same strings on that implementation

      The code they were looking at was used for writing the table, but they were testing the one that read it (which is instead correct).

      though judging by the recent comments someone’s found something.

      Yeah that’s me :)The translation using an associated const also works when the const block uses generic parameters. For example:

      fn require_zst<T>() {
    const { assert!(std::mem::size_of::<T>() == 0) }
}

      This can be written as:

      fn require_zst<T>() {
    struct Foo<T>(PhantomData<T>);
    impl<T> Foo<T> {
        const FOO: () = assert!(std::mem::size_of::<T>() == 0);
    }
    Foo::<T>::FOO
}

      However it cannot be written as:

      fn require_zst<T>() {
    const FOO: () = assert!(std::mem::size_of::<T>() == 0);
    FOO
}

      Because const FOO: () is an item, thus it is only lexically scoped (i.e. visible) inside require_zst, but does not inherit its generics (thus it cannot use T).

  • onlinepersona@programming.devEnglish
    22·
    1 year 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

    • Miaou@jlai.lu
      4·
      1 year 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).

    • Alex@programming.dev
      3·
      1 year ago

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