Make the Montgomery form type an associated type of Integer

Author: fjarri

src/modular/boxed_monty_form.rs

@@ -252,14 +252,14 @@ impl Retrieve for BoxedMontyForm {
 }
 
 impl MontyFormLike for BoxedMontyForm {
-    type Raw = BoxedUint;
+    type Integer = BoxedUint;
     type Params = BoxedMontyParams;
 
-    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params> {
+    fn new_params(modulus: Self::Integer) -> CtOption<Self::Params> {
         BoxedMontyParams::new(modulus)
     }
 
-    fn new(value: Self::Raw, params: Self::Params) -> Self {
+    fn new(value: Self::Integer, params: Self::Params) -> Self {
         BoxedMontyForm::new(value, params)
     }
 

src/modular/monty_form.rs

@@ -209,14 +209,14 @@ impl<const LIMBS: usize> Retrieve for MontyForm<LIMBS> {
 }
 
 impl<const LIMBS: usize> MontyFormLike for MontyForm<LIMBS> {
-    type Raw = Uint<LIMBS>;
+    type Integer = Uint<LIMBS>;
     type Params = MontyParams<LIMBS>;
 
-    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params> {
+    fn new_params(modulus: Self::Integer) -> CtOption<Self::Params> {
         MontyParams::new(&modulus)
     }
 
-    fn new(value: Self::Raw, params: Self::Params) -> Self {
+    fn new(value: Self::Integer, params: Self::Params) -> Self {
         MontyForm::new(&value, params)
     }
 

src/traits.rs

@@ -141,6 +141,10 @@ pub trait Integer:
     + WrappingShr
     + Zero
 {
+    /// The corresponding Montgomery representation,
+    /// optimized for the performance of modular operations at the price of a conversion overhead.
+    type MontyForm: MontyFormLike<Integer = Self>;
+
     /// The value `1`.
     fn one() -> Self;
 
@@ -514,16 +518,10 @@ pub trait WideningMul<Rhs = Self>: Sized {
     fn widening_mul(&self, rhs: Rhs) -> Self::Output;
 }
 
-/// This integer has a representation optimized for the performance of modular operations.
-pub trait HasMontyForm {
-    /// The representation type.
-    type MontyForm: MontyFormLike<Raw = Self>;
-}
-
 /// A representation of an integer optimized for the performance of modular operations.
 pub trait MontyFormLike {
     /// The original integer type.
-    type Raw: HasMontyForm<MontyForm = Self>;
+    type Integer: Integer<MontyForm = Self>;
 
     /// The precomputed data needed for this representation.
     type Params: Clone;
@@ -532,10 +530,10 @@ pub trait MontyFormLike {
     ///
     /// Can return `None` if `modulus` is not valid for the representation;
     /// see the documentation of the specific type for the requirements.
-    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params>;
+    fn new_params(modulus: Self::Integer) -> CtOption<Self::Params>;
 
     /// Convert the value into the representation using precomputed data.
-    fn new(value: Self::Raw, params: Self::Params) -> Self;
+    fn new(value: Self::Integer, params: Self::Params) -> Self;
 
     /// Returns zero in this representation.
     fn zero(params: Self::Params) -> Self;

src/uint.rs

@@ -41,8 +41,8 @@ mod rand;
 
 use crate::{
     modular::{BernsteinYangInverter, MontyForm},
-    Bounded, ConstCtOption, Constants, Encoding, FixedInteger, HasMontyForm, Integer, Limb,
-    NonZero, PrecomputeInverter, PrecomputeInverterWithAdjuster, Word, ZeroConstant,
+    Bounded, ConstCtOption, Constants, Encoding, FixedInteger, Integer, Limb, NonZero,
+    PrecomputeInverter, PrecomputeInverterWithAdjuster, Word, ZeroConstant,
 };
 use core::fmt;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq};
@@ -236,6 +236,8 @@ impl<const LIMBS: usize> FixedInteger for Uint<LIMBS> {
 }
 
 impl<const LIMBS: usize> Integer for Uint<LIMBS> {
+    type MontyForm = MontyForm<LIMBS>;
+
     fn one() -> Self {
         Self::ONE
     }
@@ -261,10 +263,6 @@ impl<const LIMBS: usize> Integer for Uint<LIMBS> {
     }
 }
 
-impl<const LIMBS: usize> HasMontyForm for Uint<LIMBS> {
-    type MontyForm = MontyForm<LIMBS>;
-}
-
 impl<const LIMBS: usize> ZeroConstant for Uint<LIMBS> {
     const ZERO: Self = Self::ZERO;
 }

src/uint/boxed.rs

@@ -25,7 +25,7 @@ mod sub_mod;
 #[cfg(feature = "rand_core")]
 mod rand;
 
-use crate::{modular::BoxedMontyForm, HasMontyForm, Integer, Limb, NonZero, Word, Zero};
+use crate::{modular::BoxedMontyForm, Integer, Limb, NonZero, Word, Zero};
 use alloc::{boxed::Box, vec, vec::Vec};
 use core::fmt;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq};
@@ -284,6 +284,8 @@ impl Default for BoxedUint {
 }
 
 impl Integer for BoxedUint {
+    type MontyForm = BoxedMontyForm;
+
     fn one() -> Self {
         Self::one()
     }
@@ -343,10 +345,6 @@ impl num_traits::One for BoxedUint {
     }
 }
 
-impl HasMontyForm for BoxedUint {
-    type MontyForm = BoxedMontyForm;
-}
-
 #[cfg(feature = "zeroize")]
 impl Zeroize for BoxedUint {
     fn zeroize(&mut self) {