Support non-numeric types as traits associated constants

[TomAFrench]

From the documentation:

Since associated constants can also be used in a type position, its values are limited to only other expression kinds allowed in numeric generics.

I think this is quite limiting as it would be useful to use associated types in the bignum library to implement a trait defining bignum behaviour using a given config.

Currently there's a hack where we need feed in a generic type for which the only purpose is to fake an associated constant through calling another trait method on a different trait which will return the desired constants.

/// Repeated logic per field modulus

pub type BigNumWithParams = BigNum<ParamsGetter>

pub struct ParamsGetter {}

impl ParamsGetterTrait for ParamsGetter {
    fn get_params() -> ParamsStruct {
        PARAMS
    }
}

pub global PARAMS: ParamsStruct = ParamStruct {
    // param fields
};

/// shared logic

pub struct BigNum<Params> {
    pub limbs: [u128; 3],
}

impl<T> BigNumTrait for BigNum<T>
where
    T: ParamsGetterTrait,
{

    fn do_stuff_with_params() -> Self {
        let params = T::get_params();
        Self { limbs: do_stuff(params) }
    }
}

This is pretty ugly whereas we could be able to just implement BigNumTrait on a concrete struct version of BigNumWithParams where the params are encoded in the associated constant.

@jfecher is the quoted justification a showstopper as it seems like something we should be able to deal with tbh?

[jfecher]

@TomAFrench I'm not quite sure what the desired code would be - could you post that snippet as well?

Edit: Ok, I think I pieced together what you want from the title. You want an associated constant with a struct type. I think we could allow that in theory.

Edit2: Actually, it may be more difficult than I thought. Since we need to unify these variables so they'd need to be in the type system as my original comment notes. I had forgotten how we handle these during monomorphization - that is why we require them to be in the type system currently.

[TomAFrench]

Yep, your first edit is correct. Currently if we want to implement U256 and U512 we need to use the trick mentioned in the OP along with type aliases to feed in the type used to select the params object.

pub type U256 = BigNum<U256_Params>

pub type U512 = BigNum<U512_Params>

The ideal case would be something akin to

pub struct U256 {
    pub limbs: [u128; 3],
}

impl BigNumTrait for U256 {
   let PARAMS: ParamStruct = ...

    fn do_stuff_with_params() -> Self {
        Self { limbs: do_stuff(Self::PARAMS) }
    }
}

We then remove all of the type aliases and then have a concrete implementation of BigNumTrait for each field modulus we want to support. The parameters would then be fed in through the associated constant.

[jfecher]

The ideal case would be something akin to

Couldn't you do something similar by defining a method which returns the params instead?

pub struct U256 {
    pub limbs: [u128; 3],
}

impl BigNumTrait for U256 {
    fn params() -> ParamStruct { ... }

    fn do_stuff_with_params() -> Self {
        Self { limbs: do_stuff(Self::params()) }
    }
}

[TomAFrench]

Yeah, that's a good point. We can work around this.