implement Pow for BigInt

[programmerjake]

Pow<T> is not implemented for BigInt, only for &BigInt. This causes problems for using Pow on Ratio<BigInt> since Ratio<T>'s Pow implementation requires T: Pow.

[cuviper]

Hmm, I see.

This was sort of intentional, because having Pow<_> for BigInt by value means that x.pow(y) tries to consume x, if it's not already a reference. You need an ugly (&x).pow(y) to avoid that.

We probably should have made Pow<_> for &Ratio<T> require &T: Pow<_> instead, but that will be a breaking change now.

[programmerjake]

Hmm, I see.

This was sort of intentional, because having Pow<_> for BigInt by value means that x.pow(y) tries to consume x, if it's not already a reference. You need an ugly (&x).pow(y) to avoid that.

We probably should have made Pow<_> for &Ratio<T> require &T: Pow<_> instead, but that will be a breaking change now.

I think we should just implement Pow<_> for both BigInt and &'_ BigInt, just like all the other arithmetic operations, that way users who don't want to lose the input value can just call (&x).pow(_), exactly the same as all the other arithmetic operations.

For consistency's sake, I think we should implement all of:

impl Pow<_> for BigInt { ... }
impl Pow<_> for &'_ BigInt { ... }
impl Pow<&'_ _> for BigInt { ... }
impl<'l, 'r> Pow<&'r _> for &'l BigInt { ... }
impl Pow<_> for BigUint { ... }
impl Pow<_> for &'_ BigUint { ... }
impl Pow<&'_ _> for BigUint { ... }
impl<'l, 'r> Pow<&'r _> for &'l BigUint { ... }

if that isn't acceptable, an alternate solution is:

trait PowWorkaround<Rhs> {
    type Output;
    fn pow_workaround(self, rhs: Rhs) -> Self::Output;
}

impl<Rhs> PowWorkaround<Rhs> for BigInt // also BigUint
where
    for<'a> &'a Self: Pow<Rhs, Output=Self>
{
    type Output = Self;
    fn pow_workaround(self, rhs: Rhs) -> Self {
        (&self).pow(rhs)
    }
}

impl<T, Rhs> PowWorkaround<Rhs> for T
where
    Self: Pow<Rhs>
{
    type Output = <Self as Pow<Rhs>>::Output;
    fn pow_workaround(self, rhs: Rhs) -> Self::Output {
        Pow::pow(self, rhs)
    }
}

impl<T: Integer + Clone + PowWorkaround<_, Output=T>> impl Pow<_> for &'_ Ratio<T> {
    ...
}