Attempt to remove the where bounds in arithmetic. (#7933)

* Attempt to remove the where bounds.

* Fix further and further.

* Format better.

* Update primitives/npos-elections/src/lib.rs

* fix build

* remove unused

substrate/frame/staking/src/lib.rs

@@ -305,7 +305,7 @@ use frame_support::{
 };
 use pallet_session::historical;
 use sp_runtime::{
-	Percent, Perbill, PerU16, InnerOf, RuntimeDebug, DispatchError,
+	Percent, Perbill, PerU16, RuntimeDebug, DispatchError,
 	curve::PiecewiseLinear,
 	traits::{
 		Convert, Zero, StaticLookup, CheckedSub, Saturating, SaturatedConversion,
@@ -2991,10 +2991,7 @@ impl<T: Config> Module<T> {
 	/// No storage item is updated.
 	pub fn do_phragmen<Accuracy: PerThing128>(
 		iterations: usize,
-	) -> Option<PrimitiveElectionResult<T::AccountId, Accuracy>>
-	where
-		ExtendedBalance: From<InnerOf<Accuracy>>,
-	{
+	) -> Option<PrimitiveElectionResult<T::AccountId, Accuracy>> {
 		let weight_of = Self::slashable_balance_of_fn();
 		let mut all_nominators: Vec<(T::AccountId, VoteWeight, Vec<T::AccountId>)> = Vec::new();
 		let mut all_validators = Vec::new();

substrate/frame/staking/src/offchain_election.rs

@@ -29,7 +29,7 @@ use sp_npos_elections::{
 	ExtendedBalance, CompactSolution,
 };
 use sp_runtime::{
-	offchain::storage::StorageValueRef, traits::TrailingZeroInput, PerThing, RuntimeDebug,
+	offchain::storage::StorageValueRef, traits::TrailingZeroInput, RuntimeDebug,
 };
 use sp_std::{convert::TryInto, prelude::*};
 
@@ -326,10 +326,7 @@ pub fn prepare_submission<T: Config>(
 ) -> Result<
 	(Vec<ValidatorIndex>, CompactAssignments, ElectionScore, ElectionSize),
 	OffchainElectionError,
->
-where
-	ExtendedBalance: From<<OffchainAccuracy as PerThing>::Inner>,
-{
+> {
 	// make sure that the snapshot is available.
 	let snapshot_validators =
 		<Module<T>>::snapshot_validators().ok_or(OffchainElectionError::SnapshotUnavailable)?;

substrate/primitives/arithmetic/src/lib.rs

@@ -114,19 +114,16 @@ impl_normalize_for_numeric!(u8, u16, u32, u64, u128);
 
 impl<P: PerThing> Normalizable<P> for Vec<P> {
 	fn normalize(&self, targeted_sum: P) -> Result<Vec<P>, &'static str> {
-		let inners = self
-			.iter()
-			.map(|p| p.clone().deconstruct().into())
-			.collect::<Vec<_>>();
+		let uppers =
+			self.iter().map(|p| <UpperOf<P>>::from(p.clone().deconstruct())).collect::<Vec<_>>();
 
-		let normalized = normalize(inners.as_ref(), targeted_sum.deconstruct().into())?;
+		let normalized =
+			normalize(uppers.as_ref(), <UpperOf<P>>::from(targeted_sum.deconstruct()))?;
 
-		Ok(
-			normalized
-				.into_iter()
-				.map(|i: UpperOf<P>| P::from_parts(i.saturated_into()))
-				.collect()
-		)
+		Ok(normalized
+			.into_iter()
+			.map(|i: UpperOf<P>| P::from_parts(i.saturated_into::<P::Inner>()))
+			.collect())
 	}
 }
 

substrate/primitives/arithmetic/src/per_things.rs

@@ -22,6 +22,7 @@ use sp_std::{ops, fmt, prelude::*, convert::TryInto};
 use codec::{Encode, CompactAs};
 use crate::traits::{
 	SaturatedConversion, UniqueSaturatedInto, Saturating, BaseArithmetic, Bounded, Zero, Unsigned,
+	One,
 };
 use sp_debug_derive::RuntimeDebug;
 
@@ -37,13 +38,17 @@ pub trait PerThing:
 	Sized + Saturating + Copy + Default + Eq + PartialEq + Ord + PartialOrd + Bounded + fmt::Debug
 {
 	/// The data type used to build this per-thingy.
-	type Inner: BaseArithmetic + Unsigned + Copy + fmt::Debug;
+	type Inner: BaseArithmetic + Unsigned + Copy + Into<u128> + fmt::Debug;
 
 	/// A data type larger than `Self::Inner`, used to avoid overflow in some computations.
 	/// It must be able to compute `ACCURACY^2`.
-	type Upper:
-		BaseArithmetic + Copy + From<Self::Inner> + TryInto<Self::Inner> +
-		UniqueSaturatedInto<Self::Inner> + Unsigned + fmt::Debug;
+	type Upper: BaseArithmetic
+		+ Copy
+		+ From<Self::Inner>
+		+ TryInto<Self::Inner>
+		+ UniqueSaturatedInto<Self::Inner>
+		+ Unsigned
+		+ fmt::Debug;
 
 	/// The accuracy of this type.
 	const ACCURACY: Self::Inner;
@@ -65,14 +70,14 @@ pub trait PerThing:
 	fn from_percent(x: Self::Inner) -> Self {
 		let a: Self::Inner = x.min(100.into());
 		let b: Self::Inner = 100.into();
-		Self::from_rational_approximation(a, b)
+		Self::from_rational_approximation::<Self::Inner>(a, b)
 	}
 
 	/// Return the product of multiplication of this value by itself.
 	fn square(self) -> Self {
 		let p = Self::Upper::from(self.deconstruct());
 		let q = Self::Upper::from(Self::ACCURACY);
-		Self::from_rational_approximation(p * p, q * q)
+		Self::from_rational_approximation::<Self::Upper>(p * p, q * q)
 	}
 
 	/// Multiplication that always rounds down to a whole number. The standard `Mul` rounds to the
@@ -91,8 +96,10 @@ pub trait PerThing:
 	/// # }
 	/// ```
 	fn mul_floor<N>(self, b: N) -> N
-	where N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
-		ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned
+	where
+		N: Clone + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
+			ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned,
+		Self::Inner: Into<N>,
 	{
 		overflow_prune_mul::<N, Self>(b, self.deconstruct(), Rounding::Down)
 	}
@@ -113,8 +120,10 @@ pub trait PerThing:
 	/// # }
 	/// ```
 	fn mul_ceil<N>(self, b: N) -> N
-	where N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
-		ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned
+	where
+		N: Clone + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
+			ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned,
+		Self::Inner: Into<N>
 	{
 		overflow_prune_mul::<N, Self>(b, self.deconstruct(), Rounding::Up)
 	}
@@ -129,9 +138,11 @@ pub trait PerThing:
 	/// # }
 	/// ```
 	fn saturating_reciprocal_mul<N>(self, b: N) -> N
-	where N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
-		ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
-		Unsigned
+	where
+		N: Clone + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
+			ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
+			Unsigned,
+		Self::Inner: Into<N>,
 	{
 		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::Nearest)
 	}
@@ -149,9 +160,11 @@ pub trait PerThing:
 	/// # }
 	/// ```
 	fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N
-	where N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
-		ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
-		Unsigned
+	where
+		N: Clone + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
+			ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
+			Unsigned,
+		Self::Inner: Into<N>,
 	{
 		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::Down)
 	}
@@ -169,9 +182,11 @@ pub trait PerThing:
 	/// # }
 	/// ```
 	fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N
-	where N: Clone + From<Self::Inner> + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
-		ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
-		Unsigned
+	where
+		N: Clone + UniqueSaturatedInto<Self::Inner> + ops::Rem<N, Output=N> +
+			ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Saturating +
+			Unsigned,
+		Self::Inner: Into<N>,
 	{
 		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::Up)
 	}
@@ -199,14 +214,16 @@ pub trait PerThing:
 	/// # fn main () {
 	/// // 989/100 is technically closer to 99%.
 	/// assert_eq!(
-	///		Percent::from_rational_approximation(989u64, 1000),
-	///		Percent::from_parts(98),
-	///	);
+	/// 		Percent::from_rational_approximation(989u64, 1000),
+	/// 		Percent::from_parts(98),
+	/// 	);
 	/// # }
 	/// ```
 	fn from_rational_approximation<N>(p: N, q: N) -> Self
-	where N: Clone + Ord + From<Self::Inner> + TryInto<Self::Inner> + TryInto<Self::Upper> +
-		ops::Div<N, Output=N> + ops::Rem<N, Output=N> + ops::Add<N, Output=N> + Unsigned;
+	where
+		N: Clone + Ord + TryInto<Self::Inner> + TryInto<Self::Upper> +
+			ops::Div<N, Output=N> + ops::Rem<N, Output=N> + ops::Add<N, Output=N> + Unsigned,
+		Self::Inner: Into<N>;
 }
 
 /// The rounding method to use.
@@ -221,15 +238,12 @@ enum Rounding {
 
 /// Saturating reciprocal multiplication. Compute `x / self`, saturating at the numeric
 /// bounds instead of overflowing.
-fn saturating_reciprocal_mul<N, P>(
-	x: N,
-	part: P::Inner,
-	rounding: Rounding,
-) -> N
+fn saturating_reciprocal_mul<N, P>(x: N, part: P::Inner, rounding: Rounding) -> N
 where
-	N: Clone + From<P::Inner> + UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
+	N: Clone + UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
 	Output=N> + ops::Add<N, Output=N> + ops::Rem<N, Output=N> + Saturating + Unsigned,
 	P: PerThing,
+	P::Inner: Into<N>,
 {
 	let maximum: N = P::ACCURACY.into();
 	let c = rational_mul_correction::<N, P>(
@@ -242,15 +256,12 @@ where
 }
 
 /// Overflow-prune multiplication. Accurately multiply a value by `self` without overflowing.
-fn overflow_prune_mul<N, P>(
-	x: N,
-	part: P::Inner,
-	rounding: Rounding,
-) -> N
+fn overflow_prune_mul<N, P>(x: N, part: P::Inner, rounding: Rounding) -> N
 where
-	N: Clone + From<P::Inner> + UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
+	N: Clone + UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
 	Output=N> + ops::Add<N, Output=N> + ops::Rem<N, Output=N> + Unsigned,
 	P: PerThing,
+	P::Inner: Into<N>,
 {
 	let maximum: N = P::ACCURACY.into();
 	let part_n: N = part.into();
@@ -267,19 +278,15 @@ where
 ///
 /// Take the remainder of `x / denom` and multiply by  `numer / denom`. The result can be added
 /// to `x / denom * numer` for an accurate result.
-fn rational_mul_correction<N, P>(
-	x: N,
-	numer: P::Inner,
-	denom: P::Inner,
-	rounding: Rounding,
-) -> N
+fn rational_mul_correction<N, P>(x: N, numer: P::Inner, denom: P::Inner, rounding: Rounding) -> N
 where
-	N: From<P::Inner> + UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
+	N: UniqueSaturatedInto<P::Inner> + ops::Div<N, Output=N> + ops::Mul<N,
 	Output=N> + ops::Add<N, Output=N> + ops::Rem<N, Output=N> + Unsigned,
 	P: PerThing,
+	P::Inner: Into<N>
 {
 	let numer_upper = P::Upper::from(numer);
-	let denom_n = N::from(denom);
+	let denom_n: N = denom.into();
 	let denom_upper = P::Upper::from(denom);
 	let rem = x.rem(denom_n);
 	// `rem` is less than `denom`, which fits in `P::Inner`.
@@ -362,14 +369,17 @@ macro_rules! implement_per_thing {
 			}
 
 			fn from_rational_approximation<N>(p: N, q: N) -> Self
-			where N: Clone + Ord + From<Self::Inner> + TryInto<Self::Inner> + TryInto<Self::Upper>
-				+ ops::Div<N, Output=N> + ops::Rem<N, Output=N> + ops::Add<N, Output=N> + Unsigned
+			where
+				N: Clone + Ord + TryInto<Self::Inner> + TryInto<Self::Upper>
+				 + ops::Div<N, Output=N> + ops::Rem<N, Output=N> + ops::Add<N, Output=N> + Unsigned
+				 + Zero + One,
+				Self::Inner: Into<N>,
 			{
 				let div_ceil = |x: N, f: N| -> N {
 					let mut o = x.clone() / f.clone();
 					let r = x.rem(f.clone());
-					if r > N::from(0) {
-						o = o + N::from(1);
+					if r > N::zero() {
+						o = o + N::one();
 					}
 					o
 				};
@@ -464,54 +474,66 @@ macro_rules! implement_per_thing {
 
 			/// See [`PerThing::from_rational_approximation`].
 			pub fn from_rational_approximation<N>(p: N, q: N) -> Self
-				where N: Clone + Ord + From<$type> + TryInto<$type> +
+				where N: Clone + Ord + TryInto<$type> +
 					TryInto<$upper_type> + ops::Div<N, Output=N> + ops::Rem<N, Output=N> +
-					ops::Add<N, Output=N> + Unsigned
+					ops::Add<N, Output=N> + Unsigned,
+					$type: Into<N>,
 			{
 				<Self as PerThing>::from_rational_approximation(p, q)
 			}
 
 			/// See [`PerThing::mul_floor`].
 			pub fn mul_floor<N>(self, b: N) -> N
-				where N: Clone + From<$type> + UniqueSaturatedInto<$type> +
-					ops::Rem<N, Output=N> + ops::Div<N, Output=N> + ops::Mul<N, Output=N> +
-					ops::Add<N, Output=N> + Unsigned
+				where
+					N: Clone + UniqueSaturatedInto<$type> +
+						ops::Rem<N, Output=N> + ops::Div<N, Output=N> + ops::Mul<N, Output=N> +
+						ops::Add<N, Output=N> + Unsigned,
+					$type: Into<N>,
+
 			{
 				PerThing::mul_floor(self, b)
 			}
 
 			/// See [`PerThing::mul_ceil`].
 			pub fn mul_ceil<N>(self, b: N) -> N
-				where N: Clone + From<$type> + UniqueSaturatedInto<$type> +
-					ops::Rem<N, Output=N> + ops::Div<N, Output=N> + ops::Mul<N, Output=N> +
-					ops::Add<N, Output=N> + Unsigned
+				where
+					N: Clone + UniqueSaturatedInto<$type> +
+						ops::Rem<N, Output=N> + ops::Div<N, Output=N> + ops::Mul<N, Output=N> +
+						ops::Add<N, Output=N> + Unsigned,
+					$type: Into<N>,
 			{
 				PerThing::mul_ceil(self, b)
 			}
 
 			/// See [`PerThing::saturating_reciprocal_mul`].
 			pub fn saturating_reciprocal_mul<N>(self, b: N) -> N
-				where N: Clone + From<$type> + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
-					ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
-					Saturating + Unsigned
+				where
+					N: Clone + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
+						ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
+						Saturating + Unsigned,
+					$type: Into<N>,
 			{
 				PerThing::saturating_reciprocal_mul(self, b)
 			}
 
 			/// See [`PerThing::saturating_reciprocal_mul_floor`].
 			pub fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N
-				where N: Clone + From<$type> + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
-					ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
-					Saturating + Unsigned
+				where
+					N: Clone + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
+						ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
+						Saturating + Unsigned,
+					$type: Into<N>,
 			{
 				PerThing::saturating_reciprocal_mul_floor(self, b)
 			}
 
 			/// See [`PerThing::saturating_reciprocal_mul_ceil`].
 			pub fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N
-				where N: Clone + From<$type> + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
-					ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
-					Saturating + Unsigned
+				where
+					N: Clone + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N> +
+						ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> +
+						Saturating + Unsigned,
+					$type: Into<N>,
 			{
 				PerThing::saturating_reciprocal_mul_ceil(self, b)
 			}
@@ -611,8 +633,9 @@ macro_rules! implement_per_thing {
 		/// This is tailored to be used with a balance type.
 		impl<N> ops::Mul<N> for $name
 		where
-			N: Clone + From<$type> + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N>
+			N: Clone + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N>
 				+ ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned,
+			$type: Into<N>,
 		{
 			type Output = N;
 			fn mul(self, b: N) -> Self::Output {

substrate/primitives/election-providers/src/onchain.rs

@@ -17,7 +17,6 @@
 
 //! An implementation of [`ElectionProvider`] that does an on-chain sequential phragmen.
 
-use sp_arithmetic::InnerOf;
 use crate::{ElectionDataProvider, ElectionProvider};
 use sp_npos_elections::*;
 use sp_std::{collections::btree_map::BTreeMap, marker::PhantomData, prelude::*};
@@ -58,10 +57,7 @@ pub trait Config {
 	type DataProvider: ElectionDataProvider<Self::AccountId, Self::BlockNumber>;
 }
 
-impl<T: Config> ElectionProvider<T::AccountId, T::BlockNumber> for OnChainSequentialPhragmen<T>
-where
-	ExtendedBalance: From<InnerOf<T::Accuracy>>,
-{
+impl<T: Config> ElectionProvider<T::AccountId, T::BlockNumber> for OnChainSequentialPhragmen<T> {
 	type Error = Error;
 	type DataProvider = T::DataProvider;
 

substrate/primitives/npos-elections/benches/phragmen.rs

@@ -65,7 +65,6 @@ mod bench_closure_and_slice {
 	) -> Vec<StakedAssignment<A>>
 	where
 		T: sp_std::ops::Mul<ExtendedBalance, Output = ExtendedBalance>,
-		ExtendedBalance: From<<T as PerThing>::Inner>,
 	{
 		ratio
 			.into_iter()

substrate/primitives/npos-elections/src/helpers.rs

@@ -17,11 +17,8 @@
 
 //! Helper methods for npos-elections.
 
-use crate::{
-	Assignment, Error, ExtendedBalance, IdentifierT, PerThing128, StakedAssignment, VoteWeight,
-	WithApprovalOf,
-};
-use sp_arithmetic::{InnerOf, PerThing};
+use crate::{Assignment, Error, IdentifierT, PerThing128, StakedAssignment, VoteWeight, WithApprovalOf};
+use sp_arithmetic::PerThing;
 use sp_std::prelude::*;
 
 /// Converts a vector of ratio assignments into ones with absolute budget value.
@@ -33,7 +30,6 @@ pub fn assignment_ratio_to_staked<A: IdentifierT, P: PerThing128, FS>(
 ) -> Vec<StakedAssignment<A>>
 where
 	for<'r> FS: Fn(&'r A) -> VoteWeight,
-	ExtendedBalance: From<InnerOf<P>>,
 {
 	ratios
 		.into_iter()
@@ -51,7 +47,6 @@ pub fn assignment_ratio_to_staked_normalized<A: IdentifierT, P: PerThing128, FS>
 ) -> Result<Vec<StakedAssignment<A>>, Error>
 where
 	for<'r> FS: Fn(&'r A) -> VoteWeight,
-	ExtendedBalance: From<InnerOf<P>>,
 {
 	let mut staked = assignment_ratio_to_staked(ratio, &stake_of);
 	staked
@@ -68,24 +63,19 @@ where
 /// Note that this will NOT attempt at normalizing the result.
 pub fn assignment_staked_to_ratio<A: IdentifierT, P: PerThing>(
 	staked: Vec<StakedAssignment<A>>,
-) -> Vec<Assignment<A, P>>
-where
-	ExtendedBalance: From<InnerOf<P>>,
-{
+) -> Vec<Assignment<A, P>> {
 	staked.into_iter().map(|a| a.into_assignment()).collect()
 }
 
 /// Same as [`assignment_staked_to_ratio`] and try and do normalization.
 pub fn assignment_staked_to_ratio_normalized<A: IdentifierT, P: PerThing128>(
 	staked: Vec<StakedAssignment<A>>,
-) -> Result<Vec<Assignment<A, P>>, Error>
-where
-	ExtendedBalance: From<InnerOf<P>>,
-{
+) -> Result<Vec<Assignment<A, P>>, Error> {
 	let mut ratio = staked.into_iter().map(|a| a.into_assignment()).collect::<Vec<_>>();
-	ratio.iter_mut().map(|a|
-		a.try_normalize().map_err(|err| Error::ArithmeticError(err))
-	).collect::<Result<_, _>>()?;
+	ratio
+		.iter_mut()
+		.map(|a| a.try_normalize().map_err(|err| Error::ArithmeticError(err)))
+		.collect::<Result<_, _>>()?;
 	Ok(ratio)
 }
 

substrate/primitives/npos-elections/src/lib.rs

@@ -75,7 +75,7 @@
 
 use sp_arithmetic::{
 	traits::{Bounded, UniqueSaturatedInto, Zero},
-	InnerOf, Normalizable, PerThing, Rational128, ThresholdOrd,
+	Normalizable, PerThing, Rational128, ThresholdOrd,
 };
 use sp_std::{
 	cell::RefCell,
@@ -209,7 +209,6 @@ pub trait CompactSolution: Sized {
 	where
 		for<'r> FS: Fn(&'r A) -> VoteWeight,
 		A: IdentifierT,
-		ExtendedBalance: From<InnerOf<Self::Accuracy>>,
 	{
 		let ratio = self.into_assignment(voter_at, target_at)?;
 		let staked = helpers::assignment_ratio_to_staked_normalized(ratio, stake_of)?;
@@ -332,14 +331,14 @@ impl<AccountId: IdentifierT> Voter<AccountId> {
 	/// Note that this might create _un-normalized_ assignments, due to accuracy loss of `P`. Call
 	/// site might compensate by calling `normalize()` on the returned `Assignment` as a
 	/// post-precessing.
-	pub fn into_assignment<P: PerThing>(self) -> Option<Assignment<AccountId, P>>
-	where
-		ExtendedBalance: From<InnerOf<P>>,
-	{
+	pub fn into_assignment<P: PerThing>(self) -> Option<Assignment<AccountId, P>> {
 		let who = self.who;
 		let budget = self.budget;
-		let distribution = self.edges.into_iter().filter_map(|e| {
-			let per_thing = P::from_rational_approximation(e.weight, budget);
+		let distribution = self
+			.edges
+			.into_iter()
+			.filter_map(|e| {
+				let per_thing = P::from_rational_approximation(e.weight, budget);
 			// trim zero edges.
 			if per_thing.is_zero() { None } else { Some((e.who, per_thing)) }
 		}).collect::<Vec<_>>();
@@ -507,7 +506,6 @@ impl<AccountId> StakedAssignment<AccountId> {
 	/// can never be re-created and does not mean anything useful anymore.
 	pub fn into_assignment<P: PerThing>(self) -> Assignment<AccountId, P>
 	where
-		ExtendedBalance: From<InnerOf<P>>,
 		AccountId: IdentifierT,
 	{
 		let stake = self.total();
@@ -706,10 +704,7 @@ where
 /// greater or less than `that`.
 ///
 /// Note that the third component should be minimized.
-pub fn is_score_better<P: PerThing>(this: ElectionScore, that: ElectionScore, epsilon: P) -> bool
-where
-	ExtendedBalance: From<InnerOf<P>>,
-{
+pub fn is_score_better<P: PerThing>(this: ElectionScore, that: ElectionScore, epsilon: P) -> bool {
 	match this
 		.iter()
 		.zip(that.iter())

substrate/primitives/npos-elections/src/mock.rs

@@ -22,7 +22,7 @@
 use crate::*;
 use sp_arithmetic::{
 	traits::{One, SaturatedConversion, Zero},
-	InnerOf, PerThing,
+	PerThing,
 };
 use sp_runtime::assert_eq_error_rate;
 use sp_std::collections::btree_map::BTreeMap;
@@ -321,9 +321,7 @@ pub(crate) fn run_and_compare<Output: PerThing128>(
 	voters: Vec<(AccountId, Vec<AccountId>)>,
 	stake_of: &Box<dyn Fn(&AccountId) -> VoteWeight>,
 	to_elect: usize,
-) where
-	ExtendedBalance: From<InnerOf<Output>>,
-{
+) {
 	// run fixed point code.
 	let ElectionResult { winners, assignments } = seq_phragmen::<_, Output>(
 		to_elect,

substrate/primitives/npos-elections/src/phragmen.rs

@@ -27,7 +27,7 @@ use crate::{
 use sp_arithmetic::{
 	helpers_128bit::multiply_by_rational,
 	traits::{Bounded, Zero},
-	InnerOf, Rational128,
+	Rational128,
 };
 use sp_std::prelude::*;
 
@@ -68,10 +68,7 @@ pub fn seq_phragmen<AccountId: IdentifierT, P: PerThing128>(
 	initial_candidates: Vec<AccountId>,
 	initial_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
 	balance: Option<(usize, ExtendedBalance)>,
-) -> Result<ElectionResult<AccountId, P>, crate::Error>
-where
-	ExtendedBalance: From<InnerOf<P>>,
-{
+) -> Result<ElectionResult<AccountId, P>, crate::Error> {
 	let (candidates, voters) = setup_inputs(initial_candidates, initial_voters);
 
 	let (candidates, mut voters) = seq_phragmen_core::<AccountId>(

substrate/primitives/npos-elections/src/phragmms.rs

@@ -25,7 +25,7 @@ use crate::{
 	IdentifierT, ElectionResult, ExtendedBalance, setup_inputs, VoteWeight, Voter, CandidatePtr,
 	balance, PerThing128,
 };
-use sp_arithmetic::{PerThing, InnerOf, Rational128, traits::Bounded};
+use sp_arithmetic::{PerThing, Rational128, traits::Bounded};
 use sp_std::{prelude::*, rc::Rc};
 
 /// Execute the phragmms method.
@@ -46,10 +46,7 @@ pub fn phragmms<AccountId: IdentifierT, P: PerThing128>(
 	initial_candidates: Vec<AccountId>,
 	initial_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
 	balancing_config: Option<(usize, ExtendedBalance)>,
-) -> Result<ElectionResult<AccountId, P>, &'static str>
-where
-	ExtendedBalance: From<InnerOf<P>>,
-{
+) -> Result<ElectionResult<AccountId, P>, &'static str> {
 	let (candidates, mut voters) = setup_inputs(initial_candidates, initial_voters);
 
 	let mut winners = vec![];
@@ -89,7 +86,7 @@ where
 pub(crate) fn calculate_max_score<AccountId: IdentifierT, P: PerThing>(
 	candidates: &[CandidatePtr<AccountId>],
 	voters: &[Voter<AccountId>],
-) -> Option<CandidatePtr<AccountId>> where ExtendedBalance: From<InnerOf<P>> {
+) -> Option<CandidatePtr<AccountId>> {
 	for c_ptr in candidates.iter() {
 		let mut candidate = c_ptr.borrow_mut();
 		if !candidate.elected {