Add const initializers

[XAMPPRocky]

Hello, I've been using num-bigint for rasn. I've been working on adding static information about ASN.1's constrained types, and one of things I need for this is having a const Range<BigInt> for allowing users to be able to specify arbitrary integer ranges for their type, however I was surprised that there is no const initializer for BigInt.

It would be nice if new was made const so that you could provide BigInt types in a const context like you can with builtin integers.

[cuviper]

Only zero() could be a const constructor, because anything else requires an allocation. Even that would have to be a new inherent method, not Zero, because trait implementations can't be const yet AFAIK.

[hjiayz]

https://crates.io/crates/const_num_bigint

[cuviper]

@hjiayz -- your use of transmute is unsound. The layout of repr(Rust) types is not specified, and may not be the same even for similarly shaped types. Even if they did have a specified layout, you're relying on private implementation details that could change.

[cuviper]

The current proposal about const allocations is here: rust-lang/lang-team#129

[hjiayz]

@cuviper
need pub fn biguint_from_vec(digits: Vec<usize>) -> BigUint
like
#https://github.com/rust-num/num-bigint/issues/181#issuecomment-985698108
but this is pub(crate)

[cuviper]

No, that takes Vec<BigDigit>, and BigDigit is intentionally an internal implementation detail, subject to change. Right now it's either u32 or u64 in a way that does correspond to usize, but it used to just be u32, and in the future we might yet make different decisions if it makes sense for a particular target.

Even if we made that public, it's also invalid to convert your ConstVec<T> to Vec<T>.

https://doc.rust-lang.org/std/vec/struct.Vec.html#guarantees

Most fundamentally, Vec is and always will be a (pointer, capacity, length) triplet. No more, no less. The order of these fields is completely unspecified, and you should use the appropriate methods to modify these. The pointer will never be null, so this type is null-pointer-optimized.

[hjiayz]

@cuviper
convert &'static ConstVec<T> to &'static Vec<T> by Vec::from_raw_parts
and convert &'static ConstBigUint to &'static BigUint by Vec::from_raw_parts and biguint_from_vec

[cuviper]

Vec::from_raw_parts is not const, only the empty Vec::new.

[hjiayz]

@cuviper

use std::mem::ManuallyDrop;

#[derive(Debug)]
struct ConstFoo(&'static [u8]);

#[derive(Debug)]
struct Foo(Vec<u8>);

impl ConstFoo {
    #[inline]
    pub fn get(&'static self)->ManuallyDrop<Foo>{
        ManuallyDrop::new(unsafe{Foo(
            Vec::from_raw_parts(self.0.as_ptr() as *mut u8,self.0.len(),self.0.len())
        )})
    }
    
}

const FOO : ConstFoo = ConstFoo(&[1,2,3,4,5,6]);

fn print_foo_ref(foo:&Foo){
    println!("{:?}",foo);
}

fn print_foo(){
    print_foo_ref(&*FOO.get());
}

fn main(){
    print_foo();
}