Const expressions inside trait?

Question

I have a trait that look like this:

pub trait Buf<const N: usize> {
    fn to_buf(&self) -> [u8; N];
    fn from_buf(buf: [u8; N]) -> Self;
}

However I want to do something like this:

trait Buf {
    const N: usize;
    fn to_buf(&self) -> [u8; Self::N];
    fn from_buf(buf: [u8; Self::N]) -> Self;
}

It give me this error (playground):

   |
   |     fn to_buf(&self) -> [u8; Self::N];
   |                              ^^^^^^^ cannot perform const operation using `Self`
   |
   = note: type parameters may not be used in const expressions
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

Is it possible?

Unfortunately what you're asking for is [not yet possible](https://github.com/rust-lang/rust/issues/60551) in stable Rust. It does [build on nightly](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=74be8425c7562d31bea4bbcac23aff29), though. — user4815162342, Nov 20 '21 at 21:33
Ok! at this point I would like to close this issue for now, as this syntax doesn't supported, yet... Thanks to all for yours time! — Nur, Nov 24 '21 at 12:03

score 1 · Accepted Answer · answered Nov 24 '21 at 12:00

After some research, I found out that, In nightly, Rust allow us to use generic const expression, under this (#![feature(generic_const_exprs)]) feature flag,

However, This is still far from being stable.

#![allow(warnings)]
#![feature(generic_const_exprs)]

trait Buf {
    const N: usize;
    fn to_buf(&self) -> [u8; Self::N];
    fn from_buf(buf: [u8; Self::N]) -> Self;
}
macro_rules! impl_trait {
    ($name:ident for $($t:ty:$N:literal)*) => ($(
        impl $name for $t {
            const N: usize = $N;
            fn to_buf(&self) -> [u8; $N] {
                self.to_le_bytes()
            }
            fn from_buf(bytes: [u8; $N]) -> Self {
                Self::from_le_bytes(bytes)
            }
        }
    )*)
}
impl_trait!(Buf for u8:1 u16:2 u32:4 i8:1 i16:2 i32:4);

fn test<T: Buf>(buf: T, rhs: [u8; T::N])
where
    [u8; T::N]:,
{
    assert_eq!(buf.to_buf(), rhs);
}

fn main() {
    test(123_u8,  [123]);
    test(123_u16, [123, 0]);
    test(123_u32, [123, 0, 0, 0]);

    test(-123i8,  [133]);
    test(-123i16, [133, 255]);
    test(-123i32, [133, 255, 255, 255]);
}

Rust Playground

score 0 · Answer 2 · answered Nov 20 '21 at 20:43

0

You can either use the <T: Buf<8>> signature, like

fn a<T: Buf<8>>(buf: T) {
    println!("{:#?}", buf.to_buf());
}

or run

#![feature(trait_alias)] 
trait Buf8 = Buf<8>;

fn a<T: Buf8>(buf: T) {
    println!("{:#?}", buf.to_buf());
}

in experimental rust.

answered Nov 20 '21 at 20:43

user1486999

61
1
3

1

You misunderstand my question... My idea is, Not to use generic const like so: `Buf<8>`, Please read full question... But thanks for your time. – Nur Nov 20 '21 at 20:57

Const expressions inside trait?

2 Answers2

Linked