RustAudio
diff --git a/‎src/bars.rs‎
Lines changed: 28 additions & 28 deletions b/‎src/bars.rs‎
Lines changed: 28 additions & 28 deletions
diff --git a/‎src/beats.rs‎
Lines changed: 29 additions & 29 deletions b/‎src/beats.rs‎
Lines changed: 29 additions & 29 deletions
diff --git a/‎src/ms.rs‎
Lines changed: 23 additions & 23 deletions b/‎src/ms.rs‎
Lines changed: 23 additions & 23 deletions
@@ -82,84 +82,84 @@ impl Bars {
 
 impl From<NumDiv> for Bars {
     fn from(n: NumDiv) -> Self {
-        Bars(n)
+        Self(n)
     }
 }
 
 impl Add for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn add(self, rhs: Bars) -> Bars {
-        Bars(self.bars() + rhs.bars())
+    fn add(self, rhs: Self) -> Self {
+        Self(self.bars() + rhs.bars())
     }
 }
 
 impl Sub for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn sub(self, rhs: Bars) -> Bars {
-        Bars(self.bars() - rhs.bars())
+    fn sub(self, rhs: Self) -> Self {
+        Self(self.bars() - rhs.bars())
     }
 }
 
 impl Mul for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn mul(self, rhs: Bars) -> Bars {
-        Bars(self.bars() * rhs.bars())
+    fn mul(self, rhs: Self) -> Self {
+        Self(self.bars() * rhs.bars())
     }
 }
 
 impl Div for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn div(self, rhs: Bars) -> Bars {
-        Bars(self.bars() / rhs.bars())
+    fn div(self, rhs: Self) -> Self {
+        Self(self.bars() / rhs.bars())
     }
 }
 
 impl Rem for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn rem(self, rhs: Bars) -> Bars {
-        Bars(self.bars() % rhs.bars())
+    fn rem(self, rhs: Self) -> Self {
+        Self(self.bars() % rhs.bars())
     }
 }
 
 impl Neg for Bars {
-    type Output = Bars;
+    type Output = Self;
     #[inline]
-    fn neg(self) -> Bars {
-        Bars(-self.bars())
+    fn neg(self) -> Self {
+        Self(-self.bars())
     }
 }
 
 impl AddAssign for Bars {
-    fn add_assign(&mut self, rhs: Bars) {
+    fn add_assign(&mut self, rhs: Self) {
         *self = *self + rhs;
     }
 }
 
 impl SubAssign for Bars {
-    fn sub_assign(&mut self, rhs: Bars) {
+    fn sub_assign(&mut self, rhs: Self) {
         *self = *self - rhs;
     }
 }
 
 impl MulAssign for Bars {
-    fn mul_assign(&mut self, rhs: Bars) {
+    fn mul_assign(&mut self, rhs: Self) {
         *self = *self * rhs;
     }
 }
 
 impl DivAssign for Bars {
-    fn div_assign(&mut self, rhs: Bars) {
+    fn div_assign(&mut self, rhs: Self) {
         *self = *self / rhs;
     }
 }
 
 impl RemAssign for Bars {
-    fn rem_assign(&mut self, rhs: Bars) {
+    fn rem_assign(&mut self, rhs: Self) {
         *self = *self % rhs;
     }
 }
@@ -174,10 +174,10 @@ impl ToPrimitive for Bars {
 }
 
 impl FromPrimitive for Bars {
-    fn from_u64(n: u64) -> Option<Bars> {
-        Some(Bars(n as NumDiv))
+    fn from_u64(n: u64) -> Option<Self> {
+        Some(Self(n as NumDiv))
     }
-    fn from_i64(n: i64) -> Option<Bars> {
-        Some(Bars(n as NumDiv))
+    fn from_i64(n: i64) -> Option<Self> {
+        Some(Self(n as NumDiv))
     }
 }
@@ -34,7 +34,7 @@ impl Beats {
 
     /// Return the number of beats.
     #[inline]
-    pub fn beats(&self) -> NumDiv { let Beats(num) = *self; num }
+    pub fn beats(&self) -> NumDiv { let Self(num) = *self; num }
 
     /// Convert to the equivalent duration as a number of Bars.
     #[inline]
@@ -82,84 +82,84 @@ impl Beats {
 
 impl From<NumDiv> for Beats {
     fn from(n: NumDiv) -> Self {
-        Beats(n)
+        Self(n)
     }
 }
 
 impl Add for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn add(self, rhs: Beats) -> Beats {
-        Beats(self.beats() + rhs.beats())
+    fn add(self, rhs: Self) -> Self {
+        Self(self.beats() + rhs.beats())
     }
 }
 
 impl Sub for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn sub(self, rhs: Beats) -> Beats {
-        Beats(self.beats() - rhs.beats())
+    fn sub(self, rhs: Self) -> Self {
+        Self(self.beats() - rhs.beats())
     }
 }
 
 impl Mul for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn mul(self, rhs: Beats) -> Beats {
-        Beats(self.beats() * rhs.beats())
+    fn mul(self, rhs: Self) -> Self {
+        Self(self.beats() * rhs.beats())
     }
 }
 
 impl Div for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn div(self, rhs: Beats) -> Beats {
-        Beats(self.beats() / rhs.beats())
+    fn div(self, rhs: Self) -> Self {
+        Self(self.beats() / rhs.beats())
     }
 }
 
 impl Rem for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn rem(self, rhs: Beats) -> Beats {
-        Beats(self.beats() % rhs.beats())
+    fn rem(self, rhs: Self) -> Self {
+        Self(self.beats() % rhs.beats())
     }
 }
 
 impl Neg for Beats {
-    type Output = Beats;
+    type Output = Self;
     #[inline]
-    fn neg(self) -> Beats {
-        Beats(-self.beats())
+    fn neg(self) -> Self {
+        Self(-self.beats())
     }
 }
 
 impl AddAssign for Beats {
-    fn add_assign(&mut self, rhs: Beats) {
+    fn add_assign(&mut self, rhs: Self) {
         *self = *self + rhs;
     }
 }
 
 impl SubAssign for Beats {
-    fn sub_assign(&mut self, rhs: Beats) {
+    fn sub_assign(&mut self, rhs: Self) {
         *self = *self - rhs;
     }
 }
 
 impl MulAssign for Beats {
-    fn mul_assign(&mut self, rhs: Beats) {
+    fn mul_assign(&mut self, rhs: Self) {
         *self = *self * rhs;
     }
 }
 
 impl DivAssign for Beats {
-    fn div_assign(&mut self, rhs: Beats) {
+    fn div_assign(&mut self, rhs: Self) {
         *self = *self / rhs;
     }
 }
 
 impl RemAssign for Beats {
-    fn rem_assign(&mut self, rhs: Beats) {
+    fn rem_assign(&mut self, rhs: Self) {
         *self = *self % rhs;
     }
 }
@@ -174,10 +174,10 @@ impl ToPrimitive for Beats {
 }
 
 impl FromPrimitive for Beats {
-    fn from_u64(n: u64) -> Option<Beats> {
-        Some(Beats(n as NumDiv))
+    fn from_u64(n: u64) -> Option<Self> {
+        Some(Self(n as NumDiv))
     }
-    fn from_i64(n: i64) -> Option<Beats> {
-        Some(Beats(n as NumDiv))
+    fn from_i64(n: i64) -> Option<Self> {
+        Some(Self(n as NumDiv))
     }
 }
@@ -77,79 +77,79 @@ impl From<calc::Ms> for Ms {
 }
 
 impl Add for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn add(self, rhs: Ms) -> Ms {
-        Ms(self.ms() + rhs.ms())
+    fn add(self, rhs: Self) -> Self {
+        Self(self.ms() + rhs.ms())
     }
 }
 
 impl Sub for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn sub(self, rhs: Ms) -> Ms {
-        Ms(self.ms() - rhs.ms())
+    fn sub(self, rhs: Self) -> Self {
+        Self(self.ms() - rhs.ms())
     }
 }
 
 impl Mul for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn mul(self, rhs: Ms) -> Ms {
-        Ms(self.ms() * rhs.ms())
+    fn mul(self, rhs: Self) -> Self {
+        Self(self.ms() * rhs.ms())
     }
 }
 
 impl Div for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn div(self, rhs: Ms) -> Ms {
-        Ms(self.ms() / rhs.ms())
+    fn div(self, rhs: Self) -> Self {
+        Self(self.ms() / rhs.ms())
     }
 }
 
 impl Rem for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn rem(self, rhs: Ms) -> Ms {
-        Ms(self.ms() % rhs.ms())
+    fn rem(self, rhs: Self) -> Self {
+        Self(self.ms() % rhs.ms())
     }
 }
 
 impl Neg for Ms {
-    type Output = Ms;
+    type Output = Self;
     #[inline]
-    fn neg(self) -> Ms {
-        Ms(-self.ms())
+    fn neg(self) -> Self {
+        Self(-self.ms())
     }
 }
 
 impl AddAssign for Ms {
-    fn add_assign(&mut self, rhs: Ms) {
+    fn add_assign(&mut self, rhs: Self) {
         *self = *self + rhs;
     }
 }
 
 impl SubAssign for Ms {
-    fn sub_assign(&mut self, rhs: Ms) {
+    fn sub_assign(&mut self, rhs: Self) {
         *self = *self - rhs;
     }
 }
 
 impl MulAssign for Ms {
-    fn mul_assign(&mut self, rhs: Ms) {
+    fn mul_assign(&mut self, rhs: Self) {
         *self = *self * rhs;
     }
 }
 
 impl DivAssign for Ms {
-    fn div_assign(&mut self, rhs: Ms) {
+    fn div_assign(&mut self, rhs: Self) {
         *self = *self / rhs;
     }
 }
 
 impl RemAssign for Ms {
-    fn rem_assign(&mut self, rhs: Ms) {
+    fn rem_assign(&mut self, rhs: Self) {
         *self = *self % rhs;
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -82,84 +82,84 @@ impl Bars {`
`82`	`82`
`83`	`83`	`impl From<NumDiv> for Bars {`
`84`	`84`	`fn from(n: NumDiv) -> Self {`
`85`		`- Bars(n)`
	`85`	`+ Self(n)`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`impl Add for Bars {`
`90`		`- type Output = Bars;`
	`90`	`+ type Output = Self;`
`91`	`91`	`#[inline]`
`92`		`- fn add(self, rhs: Bars) -> Bars {`
`93`		`- Bars(self.bars() + rhs.bars())`
	`92`	`+ fn add(self, rhs: Self) -> Self {`
	`93`	`+ Self(self.bars() + rhs.bars())`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl Sub for Bars {`
`98`		`- type Output = Bars;`
	`98`	`+ type Output = Self;`
`99`	`99`	`#[inline]`
`100`		`- fn sub(self, rhs: Bars) -> Bars {`
`101`		`- Bars(self.bars() - rhs.bars())`
	`100`	`+ fn sub(self, rhs: Self) -> Self {`
	`101`	`+ Self(self.bars() - rhs.bars())`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`impl Mul for Bars {`
`106`		`- type Output = Bars;`
	`106`	`+ type Output = Self;`
`107`	`107`	`#[inline]`
`108`		`- fn mul(self, rhs: Bars) -> Bars {`
`109`		`- Bars(self.bars() * rhs.bars())`
	`108`	`+ fn mul(self, rhs: Self) -> Self {`
	`109`	`+ Self(self.bars() * rhs.bars())`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`impl Div for Bars {`
`114`		`- type Output = Bars;`
	`114`	`+ type Output = Self;`
`115`	`115`	`#[inline]`
`116`		`- fn div(self, rhs: Bars) -> Bars {`
`117`		`- Bars(self.bars() / rhs.bars())`
	`116`	`+ fn div(self, rhs: Self) -> Self {`
	`117`	`+ Self(self.bars() / rhs.bars())`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`impl Rem for Bars {`
`122`		`- type Output = Bars;`
	`122`	`+ type Output = Self;`
`123`	`123`	`#[inline]`
`124`		`- fn rem(self, rhs: Bars) -> Bars {`
`125`		`- Bars(self.bars() % rhs.bars())`
	`124`	`+ fn rem(self, rhs: Self) -> Self {`
	`125`	`+ Self(self.bars() % rhs.bars())`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`impl Neg for Bars {`
`130`		`- type Output = Bars;`
	`130`	`+ type Output = Self;`
`131`	`131`	`#[inline]`
`132`		`- fn neg(self) -> Bars {`
`133`		`- Bars(-self.bars())`
	`132`	`+ fn neg(self) -> Self {`
	`133`	`+ Self(-self.bars())`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`impl AddAssign for Bars {`
`138`		`- fn add_assign(&mut self, rhs: Bars) {`
	`138`	`+ fn add_assign(&mut self, rhs: Self) {`
`139`	`139`	`self = self + rhs;`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`impl SubAssign for Bars {`
`144`		`- fn sub_assign(&mut self, rhs: Bars) {`
	`144`	`+ fn sub_assign(&mut self, rhs: Self) {`
`145`	`145`	`self = self - rhs;`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`impl MulAssign for Bars {`
`150`		`- fn mul_assign(&mut self, rhs: Bars) {`
	`150`	`+ fn mul_assign(&mut self, rhs: Self) {`
`151`	`151`	`self = self * rhs;`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`impl DivAssign for Bars {`
`156`		`- fn div_assign(&mut self, rhs: Bars) {`
	`156`	`+ fn div_assign(&mut self, rhs: Self) {`
`157`	`157`	`self = self / rhs;`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`impl RemAssign for Bars {`
`162`		`- fn rem_assign(&mut self, rhs: Bars) {`
	`162`	`+ fn rem_assign(&mut self, rhs: Self) {`
`163`	`163`	`self = self % rhs;`
`164`	`164`	`}`
`165`	`165`	`}`
`@@ -174,10 +174,10 @@ impl ToPrimitive for Bars {`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`impl FromPrimitive for Bars {`
`177`		`- fn from_u64(n: u64) -> Option<Bars> {`
`178`		`- Some(Bars(n as NumDiv))`
	`177`	`+ fn from_u64(n: u64) -> Option<Self> {`
	`178`	`+ Some(Self(n as NumDiv))`
`179`	`179`	`}`
`180`		`- fn from_i64(n: i64) -> Option<Bars> {`
`181`		`- Some(Bars(n as NumDiv))`
	`180`	`+ fn from_i64(n: i64) -> Option<Self> {`
	`181`	`+ Some(Self(n as NumDiv))`
`182`	`182`	`}`
`183`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ impl Beats {`
`34`	`34`
`35`	`35`	`/// Return the number of beats.`
`36`	`36`	`#[inline]`
`37`		`- pub fn beats(&self) -> NumDiv { let Beats(num) = *self; num }`
	`37`	`+ pub fn beats(&self) -> NumDiv { let Self(num) = *self; num }`
`38`	`38`
`39`	`39`	`/// Convert to the equivalent duration as a number of Bars.`
`40`	`40`	`#[inline]`
`@@ -82,84 +82,84 @@ impl Beats {`
`82`	`82`
`83`	`83`	`impl From<NumDiv> for Beats {`
`84`	`84`	`fn from(n: NumDiv) -> Self {`
`85`		`- Beats(n)`
	`85`	`+ Self(n)`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`impl Add for Beats {`
`90`		`- type Output = Beats;`
	`90`	`+ type Output = Self;`
`91`	`91`	`#[inline]`
`92`		`- fn add(self, rhs: Beats) -> Beats {`
`93`		`- Beats(self.beats() + rhs.beats())`
	`92`	`+ fn add(self, rhs: Self) -> Self {`
	`93`	`+ Self(self.beats() + rhs.beats())`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl Sub for Beats {`
`98`		`- type Output = Beats;`
	`98`	`+ type Output = Self;`
`99`	`99`	`#[inline]`
`100`		`- fn sub(self, rhs: Beats) -> Beats {`
`101`		`- Beats(self.beats() - rhs.beats())`
	`100`	`+ fn sub(self, rhs: Self) -> Self {`
	`101`	`+ Self(self.beats() - rhs.beats())`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`impl Mul for Beats {`
`106`		`- type Output = Beats;`
	`106`	`+ type Output = Self;`
`107`	`107`	`#[inline]`
`108`		`- fn mul(self, rhs: Beats) -> Beats {`
`109`		`- Beats(self.beats() * rhs.beats())`
	`108`	`+ fn mul(self, rhs: Self) -> Self {`
	`109`	`+ Self(self.beats() * rhs.beats())`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`impl Div for Beats {`
`114`		`- type Output = Beats;`
	`114`	`+ type Output = Self;`
`115`	`115`	`#[inline]`
`116`		`- fn div(self, rhs: Beats) -> Beats {`
`117`		`- Beats(self.beats() / rhs.beats())`
	`116`	`+ fn div(self, rhs: Self) -> Self {`
	`117`	`+ Self(self.beats() / rhs.beats())`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`impl Rem for Beats {`
`122`		`- type Output = Beats;`
	`122`	`+ type Output = Self;`
`123`	`123`	`#[inline]`
`124`		`- fn rem(self, rhs: Beats) -> Beats {`
`125`		`- Beats(self.beats() % rhs.beats())`
	`124`	`+ fn rem(self, rhs: Self) -> Self {`
	`125`	`+ Self(self.beats() % rhs.beats())`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`impl Neg for Beats {`
`130`		`- type Output = Beats;`
	`130`	`+ type Output = Self;`
`131`	`131`	`#[inline]`
`132`		`- fn neg(self) -> Beats {`
`133`		`- Beats(-self.beats())`
	`132`	`+ fn neg(self) -> Self {`
	`133`	`+ Self(-self.beats())`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`impl AddAssign for Beats {`
`138`		`- fn add_assign(&mut self, rhs: Beats) {`
	`138`	`+ fn add_assign(&mut self, rhs: Self) {`
`139`	`139`	`self = self + rhs;`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`impl SubAssign for Beats {`
`144`		`- fn sub_assign(&mut self, rhs: Beats) {`
	`144`	`+ fn sub_assign(&mut self, rhs: Self) {`
`145`	`145`	`self = self - rhs;`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`impl MulAssign for Beats {`
`150`		`- fn mul_assign(&mut self, rhs: Beats) {`
	`150`	`+ fn mul_assign(&mut self, rhs: Self) {`
`151`	`151`	`self = self * rhs;`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`impl DivAssign for Beats {`
`156`		`- fn div_assign(&mut self, rhs: Beats) {`
	`156`	`+ fn div_assign(&mut self, rhs: Self) {`
`157`	`157`	`self = self / rhs;`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`impl RemAssign for Beats {`
`162`		`- fn rem_assign(&mut self, rhs: Beats) {`
	`162`	`+ fn rem_assign(&mut self, rhs: Self) {`
`163`	`163`	`self = self % rhs;`
`164`	`164`	`}`
`165`	`165`	`}`
`@@ -174,10 +174,10 @@ impl ToPrimitive for Beats {`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`impl FromPrimitive for Beats {`
`177`		`- fn from_u64(n: u64) -> Option<Beats> {`
`178`		`- Some(Beats(n as NumDiv))`
	`177`	`+ fn from_u64(n: u64) -> Option<Self> {`
	`178`	`+ Some(Self(n as NumDiv))`
`179`	`179`	`}`
`180`		`- fn from_i64(n: i64) -> Option<Beats> {`
`181`		`- Some(Beats(n as NumDiv))`
	`180`	`+ fn from_i64(n: i64) -> Option<Self> {`
	`181`	`+ Some(Self(n as NumDiv))`
`182`	`182`	`}`
`183`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,79 +77,79 @@ impl From<calc::Ms> for Ms {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`impl Add for Ms {`
`80`		`- type Output = Ms;`
	`80`	`+ type Output = Self;`
`81`	`81`	`#[inline]`
`82`		`- fn add(self, rhs: Ms) -> Ms {`
`83`		`- Ms(self.ms() + rhs.ms())`
	`82`	`+ fn add(self, rhs: Self) -> Self {`
	`83`	`+ Self(self.ms() + rhs.ms())`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`impl Sub for Ms {`
`88`		`- type Output = Ms;`
	`88`	`+ type Output = Self;`
`89`	`89`	`#[inline]`
`90`		`- fn sub(self, rhs: Ms) -> Ms {`
`91`		`- Ms(self.ms() - rhs.ms())`
	`90`	`+ fn sub(self, rhs: Self) -> Self {`
	`91`	`+ Self(self.ms() - rhs.ms())`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`impl Mul for Ms {`
`96`		`- type Output = Ms;`
	`96`	`+ type Output = Self;`
`97`	`97`	`#[inline]`
`98`		`- fn mul(self, rhs: Ms) -> Ms {`
`99`		`- Ms(self.ms() * rhs.ms())`
	`98`	`+ fn mul(self, rhs: Self) -> Self {`
	`99`	`+ Self(self.ms() * rhs.ms())`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`impl Div for Ms {`
`104`		`- type Output = Ms;`
	`104`	`+ type Output = Self;`
`105`	`105`	`#[inline]`
`106`		`- fn div(self, rhs: Ms) -> Ms {`
`107`		`- Ms(self.ms() / rhs.ms())`
	`106`	`+ fn div(self, rhs: Self) -> Self {`
	`107`	`+ Self(self.ms() / rhs.ms())`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`impl Rem for Ms {`
`112`		`- type Output = Ms;`
	`112`	`+ type Output = Self;`
`113`	`113`	`#[inline]`
`114`		`- fn rem(self, rhs: Ms) -> Ms {`
`115`		`- Ms(self.ms() % rhs.ms())`
	`114`	`+ fn rem(self, rhs: Self) -> Self {`
	`115`	`+ Self(self.ms() % rhs.ms())`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`impl Neg for Ms {`
`120`		`- type Output = Ms;`
	`120`	`+ type Output = Self;`
`121`	`121`	`#[inline]`
`122`		`- fn neg(self) -> Ms {`
`123`		`- Ms(-self.ms())`
	`122`	`+ fn neg(self) -> Self {`
	`123`	`+ Self(-self.ms())`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`impl AddAssign for Ms {`
`128`		`- fn add_assign(&mut self, rhs: Ms) {`
	`128`	`+ fn add_assign(&mut self, rhs: Self) {`
`129`	`129`	`self = self + rhs;`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`impl SubAssign for Ms {`
`134`		`- fn sub_assign(&mut self, rhs: Ms) {`
	`134`	`+ fn sub_assign(&mut self, rhs: Self) {`
`135`	`135`	`self = self - rhs;`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`impl MulAssign for Ms {`
`140`		`- fn mul_assign(&mut self, rhs: Ms) {`
	`140`	`+ fn mul_assign(&mut self, rhs: Self) {`
`141`	`141`	`self = self * rhs;`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`impl DivAssign for Ms {`
`146`		`- fn div_assign(&mut self, rhs: Ms) {`
	`146`	`+ fn div_assign(&mut self, rhs: Self) {`
`147`	`147`	`self = self / rhs;`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`impl RemAssign for Ms {`
`152`		`- fn rem_assign(&mut self, rhs: Ms) {`
	`152`	`+ fn rem_assign(&mut self, rhs: Self) {`
`153`	`153`	`self = self % rhs;`
`154`	`154`	`}`
`155`	`155`	`}`