core_extensions

Trait ConstVal

Source 
pub trait ConstVal {
    type Ty;

    const VAL: Self::Ty;

    // Provided method
    fn const_val(&self) -> Self::Ty { ... }
}
Available on crate feature const_val only.
Expand description

For types that represent constants.

§Examples

§Quasiconstants

Using the quasiconst macro to declare types that implement this trait, and emulate generic constants.

This example requires Rust 1.46.0, because it uses a while loop in a const context.

use core_extensions::{ConstVal, getconst, quasiconst};

const LEN: usize = 8;

quasiconst!{
   const FIBNUMS[T: ConstVal<Ty = u128>]: &'static [u128; LEN] = {
       let mut ret = [T::VAL; LEN];
       let mut i = 2;
       while i < LEN {
           ret[i] = ret[i - 1] + ret[i - 2];
           i += 1;
       }
       &{ret}
   };
    
   const ONE: u128 = 1;
   const FOUR: u128 = 4;
   const SEVEN: u128 = 7;
}

assert_eq!(getconst!(FIBNUMS<ONE>), &[1, 1, 2, 3, 5, 8, 13, 21]);
assert_eq!(getconst!(FIBNUMS<FOUR>), &[4, 4, 8, 12, 20, 32, 52, 84]);
assert_eq!(getconst!(FIBNUMS<SEVEN>), &[7, 7, 14, 21, 35, 56, 91, 147]);

§Manual impl

use core_extensions::{ConstVal, getconst};
 
struct Foo;

struct Bar<T>(std::marker::PhantomData<T>);
 
impl ConstVal for Foo {
    type Ty = u32;
    const VAL: Self::Ty = 3;
}
 
impl<T> ConstVal for Bar<T> 
where
    T: ConstVal<Ty = u32>,
{
    type Ty = u32;

    const VAL: Self::Ty = T::VAL * 3 / 2;
}
 
assert_eq!(getconst!(Foo), 3);
assert_eq!(getconst!(Bar<Foo>), 4);
assert_eq!(getconst!(Bar<Bar<Foo>>), 6);
assert_eq!(getconst!(Bar<Bar<Bar<Foo>>>), 9);

Required Associated Constants§

Source

const VAL: Self::Ty

The constant this represents.

Required Associated Types§

Source

type Ty

The type of the constant this represents.

Provided Methods§

Source

fn const_val(&self) -> Self::Ty

Gets the constant this represents.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§