Use fully qualified syntax

GrantM11235 · GrantM11235 · commit a5ab6a6bae95 · 2021-09-08T20:46:43.000-05:00
diff --git a/src/adc.rs b/src/adc.rs
@@ -55,7 +55,7 @@ pub mod nb {
         type ID = T::ID;
 
         fn channel(&self) -> Self::ID {
-            (*self).channel()
+            T::channel(self)
         }
     }
 
@@ -108,7 +108,7 @@ pub mod nb {
         type Error = T::Error;
 
         fn read(&mut self, pin: &mut Pin) -> nb::Result<Word, Self::Error> {
-            (*self).read(pin)
+            T::read(self, pin)
         }
     }
 }
diff --git a/src/capture.rs b/src/capture.rs
@@ -105,26 +105,26 @@ pub mod nb {
         type Capture = T::Capture;
 
         fn capture(&mut self, channel: Self::Channel) -> nb::Result<Self::Capture, Self::Error> {
-            (*self).capture(channel)
+            T::capture(self, channel)
         }
 
         fn disable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {
-            (*self).disable(channel)
+            T::disable(self, channel)
         }
 
         fn enable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {
-            (*self).enable(channel)
+            T::enable(self, channel)
         }
 
         fn get_resolution(&self) -> Result<Self::Time, Self::Error> {
-            (**self).get_resolution()
+            T::get_resolution(self)
         }
 
         fn set_resolution<R>(&mut self, resolution: R) -> Result<(), Self::Error>
         where
             R: Into<Self::Time>,
         {
-            (*self).set_resolution(resolution)
+            T::set_resolution(self, resolution)
         }
     }
 }
diff --git a/src/delay.rs b/src/delay.rs
@@ -25,7 +25,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn delay_ms(&mut self, ms: UXX) -> Result<(), Self::Error> {
-            (*self).delay_ms(ms)
+            T::delay_ms(self, ms)
         }
     }
 
@@ -45,7 +45,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn delay_us(&mut self, us: UXX) -> Result<(), Self::Error> {
-            (*self).delay_us(us)
+            T::delay_us(self, us)
         }
     }
 }
diff --git a/src/digital.rs b/src/digital.rs
@@ -81,15 +81,15 @@ pub mod blocking {
         type Error = T::Error;
 
         fn set_low(&mut self) -> Result<(), Self::Error> {
-            (*self).set_low()
+            T::set_low(self)
         }
 
         fn set_high(&mut self) -> Result<(), Self::Error> {
-            (*self).set_high()
+            T::set_high(self)
         }
 
         fn set_state(&mut self, state: PinState) -> Result<(), Self::Error> {
-            (*self).set_state(state)
+            T::set_state(self, state)
         }
     }
 
@@ -108,11 +108,11 @@ pub mod blocking {
 
     impl<T: StatefulOutputPin> StatefulOutputPin for &mut T {
         fn is_set_high(&self) -> Result<bool, Self::Error> {
-            (**self).is_set_high()
+            T::is_set_high(self)
         }
 
         fn is_set_low(&self) -> Result<bool, Self::Error> {
-            (**self).is_set_low()
+            T::is_set_low(self)
         }
     }
 
@@ -134,7 +134,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn toggle(&mut self) -> Result<(), Self::Error> {
-            (*self).toggle()
+            T::toggle(self)
         }
     }
 
@@ -154,11 +154,11 @@ pub mod blocking {
         type Error = T::Error;
 
         fn is_high(&self) -> Result<bool, Self::Error> {
-            (*self).is_high()
+            T::is_high(self)
         }
 
         fn is_low(&self) -> Result<bool, Self::Error> {
-            (*self).is_low()
+            T::is_low(self)
         }
     }
 
diff --git a/src/i2c.rs b/src/i2c.rs
@@ -151,7 +151,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn read(&mut self, address: A, buffer: &mut [u8]) -> Result<(), Self::Error> {
-            (*self).read(address, buffer)
+            T::read(self, address, buffer)
         }
     }
 
@@ -183,7 +183,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn write(&mut self, address: A, bytes: &[u8]) -> Result<(), Self::Error> {
-            (*self).write(address, bytes)
+            T::write(self, address, bytes)
         }
     }
 
@@ -209,7 +209,7 @@ pub mod blocking {
         where
             B: IntoIterator<Item = u8>,
         {
-            (*self).write_iter(address, bytes)
+            T::write_iter(self, address, bytes)
         }
     }
 
@@ -257,7 +257,7 @@ pub mod blocking {
             bytes: &[u8],
             buffer: &mut [u8],
         ) -> Result<(), Self::Error> {
-            (*self).write_read(address, bytes, buffer)
+            T::write_read(self, address, bytes, buffer)
         }
     }
 
@@ -294,7 +294,7 @@ pub mod blocking {
         where
             B: IntoIterator<Item = u8>,
         {
-            (*self).write_iter_read(address, bytes, buffer)
+            T::write_iter_read(self, address, bytes, buffer)
         }
     }
 
@@ -344,7 +344,7 @@ pub mod blocking {
             address: A,
             operations: &mut [Operation<'a>],
         ) -> Result<(), Self::Error> {
-            (*self).exec(address, operations)
+            T::exec(self, address, operations)
         }
     }
 
@@ -380,7 +380,7 @@ pub mod blocking {
         where
             O: IntoIterator<Item = Operation<'a>>,
         {
-            (*self).exec_iter(address, operations)
+            T::exec_iter(self, address, operations)
         }
     }
 }
diff --git a/src/pwm.rs b/src/pwm.rs
@@ -112,38 +112,38 @@ pub mod blocking {
         type Duty = T::Duty;
 
         fn disable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {
-            (*self).disable(channel)
+            T::disable(self, channel)
         }
 
         fn enable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {
-            (*self).enable(channel)
+            T::enable(self, channel)
         }
 
         fn get_period(&self) -> Result<Self::Time, Self::Error> {
-            (**self).get_period()
+            T::get_period(self)
         }
 
         fn get_duty(&self, channel: &Self::Channel) -> Result<Self::Duty, Self::Error> {
-            (**self).get_duty(channel)
+            T::get_duty(self, channel)
         }
 
         fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {
-            (**self).get_max_duty()
+            T::get_max_duty(self)
         }
 
         fn set_duty(
             &mut self,
             channel: &Self::Channel,
             duty: Self::Duty,
         ) -> Result<(), Self::Error> {
-            (*self).set_duty(channel, duty)
+            T::set_duty(self, channel, duty)
         }
 
         fn set_period<P>(&mut self, period: P) -> Result<(), Self::Error>
         where
             P: Into<Self::Time>,
         {
-            (*self).set_period(period)
+            T::set_period(self, period)
         }
     }
 
@@ -185,23 +185,23 @@ pub mod blocking {
         type Duty = T::Duty;
 
         fn disable(&mut self) -> Result<(), Self::Error> {
-            (*self).disable()
+            T::disable(self)
         }
 
         fn enable(&mut self) -> Result<(), Self::Error> {
-            (*self).enable()
+            T::enable(self)
         }
 
         fn get_duty(&self) -> Result<Self::Duty, Self::Error> {
-            (**self).get_duty()
+            T::get_duty(self)
         }
 
         fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {
-            (**self).get_max_duty()
+            T::get_max_duty(self)
         }
 
         fn set_duty(&mut self, duty: Self::Duty) -> Result<(), Self::Error> {
-            (*self).set_duty(duty)
+            T::set_duty(self, duty)
         }
     }
 }
diff --git a/src/qei.rs b/src/qei.rs
@@ -88,11 +88,11 @@ pub mod blocking {
         type Count = T::Count;
 
         fn count(&self) -> Result<Self::Count, Self::Error> {
-            (*self).count()
+            T::count(self)
         }
 
         fn direction(&self) -> Result<Direction, Self::Error> {
-            (*self).direction()
+            T::direction(self)
         }
     }
 }
diff --git a/src/serial/blocking.rs b/src/serial/blocking.rs
@@ -27,10 +27,10 @@ impl<T: Write<Word>, Word> Write<Word> for &mut T {
     type Error = T::Error;
 
     fn write(&mut self, buffer: &[Word]) -> Result<(), Self::Error> {
-        (*self).write(buffer)
+        T::write(self, buffer)
     }
 
     fn flush(&mut self) -> Result<(), Self::Error> {
-        (*self).flush()
+        T::flush(self)
     }
 }
diff --git a/src/serial/nb.rs b/src/serial/nb.rs
@@ -16,7 +16,7 @@ impl<T: Read<Word>, Word> Read<Word> for &mut T {
     type Error = T::Error;
 
     fn read(&mut self) -> nb::Result<Word, Self::Error> {
-        (*self).read()
+        T::read(self)
     }
 }
 
@@ -36,10 +36,10 @@ impl<T: Write<Word>, Word> Write<Word> for &mut T {
     type Error = T::Error;
 
     fn write(&mut self, word: Word) -> nb::Result<(), Self::Error> {
-        (*self).write(word)
+        T::write(self, word)
     }
 
     fn flush(&mut self) -> nb::Result<(), Self::Error> {
-        (*self).flush()
+        T::flush(self)
     }
 }
diff --git a/src/spi/blocking.rs b/src/spi/blocking.rs
@@ -19,7 +19,7 @@ impl<T: Transfer<W>, W> Transfer<W> for &mut T {
     type Error = T::Error;
 
     fn transfer(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
-        (*self).transfer(words)
+        T::transfer(self, words)
     }
 }
 
@@ -36,7 +36,7 @@ impl<T: Write<W>, W> Write<W> for &mut T {
     type Error = T::Error;
 
     fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
-        (*self).write(words)
+        T::write(self, words)
     }
 }
 
@@ -58,7 +58,7 @@ impl<T: WriteIter<W>, W> WriteIter<W> for &mut T {
     where
         WI: IntoIterator<Item = W>,
     {
-        (*self).write_iter(words)
+        T::write_iter(self, words)
     }
 }
 
@@ -87,6 +87,6 @@ impl<T: Transactional<W>, W: 'static> Transactional<W> for &mut T {
     type Error = T::Error;
 
     fn exec<'a>(&mut self, operations: &mut [Operation<'a, W>]) -> Result<(), Self::Error> {
-        (*self).exec(operations)
+        T::exec(self, operations)
     }
 }
diff --git a/src/spi/nb.rs b/src/spi/nb.rs
@@ -34,10 +34,10 @@ impl<T: FullDuplex<Word>, Word> FullDuplex<Word> for &mut T {
     type Error = T::Error;
 
     fn read(&mut self) -> nb::Result<Word, Self::Error> {
-        (*self).read()
+        T::read(self)
     }
 
     fn write(&mut self, word: Word) -> nb::Result<(), Self::Error> {
-        (*self).write(word)
+        T::write(self, word)
     }
 }
diff --git a/src/timer.rs b/src/timer.rs
@@ -94,11 +94,11 @@ pub mod nb {
         where
             TIME: Into<Self::Time>,
         {
-            (*self).start(count)
+            T::start(self, count)
         }
 
         fn wait(&mut self) -> nb::Result<(), Self::Error> {
-            (*self).wait()
+            T::wait(self)
         }
     }
 
@@ -115,7 +115,7 @@ pub mod nb {
 
     impl<T: Cancel> Cancel for &mut T {
         fn cancel(&mut self) -> Result<(), Self::Error> {
-            (*self).cancel()
+            T::cancel(self)
         }
     }
 }
diff --git a/src/watchdog.rs b/src/watchdog.rs
@@ -20,7 +20,7 @@ pub mod blocking {
         type Error = T::Error;
 
         fn feed(&mut self) -> Result<(), Self::Error> {
-            (*self).feed()
+            T::feed(self)
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ pub mod nb {`
`55`	`55`	`type ID = T::ID;`
`56`	`56`
`57`	`57`	`fn channel(&self) -> Self::ID {`
`58`		`- (*self).channel()`
	`58`	`+ T::channel(self)`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`@@ -108,7 +108,7 @@ pub mod nb {`
`108`	`108`	`type Error = T::Error;`
`109`	`109`
`110`	`110`	`fn read(&mut self, pin: &mut Pin) -> nb::Result<Word, Self::Error> {`
`111`		`- (*self).read(pin)`
	`111`	`+ T::read(self, pin)`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,26 +105,26 @@ pub mod nb {`
`105`	`105`	`type Capture = T::Capture;`
`106`	`106`
`107`	`107`	`fn capture(&mut self, channel: Self::Channel) -> nb::Result<Self::Capture, Self::Error> {`
`108`		`- (*self).capture(channel)`
	`108`	`+ T::capture(self, channel)`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`fn disable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {`
`112`		`- (*self).disable(channel)`
	`112`	`+ T::disable(self, channel)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`fn enable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {`
`116`		`- (*self).enable(channel)`
	`116`	`+ T::enable(self, channel)`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`fn get_resolution(&self) -> Result<Self::Time, Self::Error> {`
`120`		`- (**self).get_resolution()`
	`120`	`+ T::get_resolution(self)`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`fn set_resolution<R>(&mut self, resolution: R) -> Result<(), Self::Error>`
`124`	`124`	`where`
`125`	`125`	`R: Into<Self::Time>,`
`126`	`126`	`{`
`127`		`- (*self).set_resolution(resolution)`
	`127`	`+ T::set_resolution(self, resolution)`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ pub mod blocking {`
`25`	`25`	`type Error = T::Error;`
`26`	`26`
`27`	`27`	`fn delay_ms(&mut self, ms: UXX) -> Result<(), Self::Error> {`
`28`		`- (*self).delay_ms(ms)`
	`28`	`+ T::delay_ms(self, ms)`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`@@ -45,7 +45,7 @@ pub mod blocking {`
`45`	`45`	`type Error = T::Error;`
`46`	`46`
`47`	`47`	`fn delay_us(&mut self, us: UXX) -> Result<(), Self::Error> {`
`48`		`- (*self).delay_us(us)`
	`48`	`+ T::delay_us(self, us)`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,15 +81,15 @@ pub mod blocking {`
`81`	`81`	`type Error = T::Error;`
`82`	`82`
`83`	`83`	`fn set_low(&mut self) -> Result<(), Self::Error> {`
`84`		`- (*self).set_low()`
	`84`	`+ T::set_low(self)`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`fn set_high(&mut self) -> Result<(), Self::Error> {`
`88`		`- (*self).set_high()`
	`88`	`+ T::set_high(self)`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`fn set_state(&mut self, state: PinState) -> Result<(), Self::Error> {`
`92`		`- (*self).set_state(state)`
	`92`	`+ T::set_state(self, state)`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`@@ -108,11 +108,11 @@ pub mod blocking {`
`108`	`108`
`109`	`109`	`impl<T: StatefulOutputPin> StatefulOutputPin for &mut T {`
`110`	`110`	`fn is_set_high(&self) -> Result<bool, Self::Error> {`
`111`		`- (**self).is_set_high()`
	`111`	`+ T::is_set_high(self)`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`fn is_set_low(&self) -> Result<bool, Self::Error> {`
`115`		`- (**self).is_set_low()`
	`115`	`+ T::is_set_low(self)`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`@@ -134,7 +134,7 @@ pub mod blocking {`
`134`	`134`	`type Error = T::Error;`
`135`	`135`
`136`	`136`	`fn toggle(&mut self) -> Result<(), Self::Error> {`
`137`		`- (*self).toggle()`
	`137`	`+ T::toggle(self)`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`@@ -154,11 +154,11 @@ pub mod blocking {`
`154`	`154`	`type Error = T::Error;`
`155`	`155`
`156`	`156`	`fn is_high(&self) -> Result<bool, Self::Error> {`
`157`		`- (*self).is_high()`
	`157`	`+ T::is_high(self)`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`fn is_low(&self) -> Result<bool, Self::Error> {`
`161`		`- (*self).is_low()`
	`161`	`+ T::is_low(self)`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ pub mod blocking {`
`151`	`151`	`type Error = T::Error;`
`152`	`152`
`153`	`153`	`fn read(&mut self, address: A, buffer: &mut [u8]) -> Result<(), Self::Error> {`
`154`		`- (*self).read(address, buffer)`
	`154`	`+ T::read(self, address, buffer)`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`
`@@ -183,7 +183,7 @@ pub mod blocking {`
`183`	`183`	`type Error = T::Error;`
`184`	`184`
`185`	`185`	`fn write(&mut self, address: A, bytes: &[u8]) -> Result<(), Self::Error> {`
`186`		`- (*self).write(address, bytes)`
	`186`	`+ T::write(self, address, bytes)`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`
`@@ -209,7 +209,7 @@ pub mod blocking {`
`209`	`209`	`where`
`210`	`210`	`B: IntoIterator<Item = u8>,`
`211`	`211`	`{`
`212`		`- (*self).write_iter(address, bytes)`
	`212`	`+ T::write_iter(self, address, bytes)`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`
`@@ -257,7 +257,7 @@ pub mod blocking {`
`257`	`257`	`bytes: &[u8],`
`258`	`258`	`buffer: &mut [u8],`
`259`	`259`	`) -> Result<(), Self::Error> {`
`260`		`- (*self).write_read(address, bytes, buffer)`
	`260`	`+ T::write_read(self, address, bytes, buffer)`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`@@ -294,7 +294,7 @@ pub mod blocking {`
`294`	`294`	`where`
`295`	`295`	`B: IntoIterator<Item = u8>,`
`296`	`296`	`{`
`297`		`- (*self).write_iter_read(address, bytes, buffer)`
	`297`	`+ T::write_iter_read(self, address, bytes, buffer)`
`298`	`298`	`}`
`299`	`299`	`}`
`300`	`300`
`@@ -344,7 +344,7 @@ pub mod blocking {`
`344`	`344`	`address: A,`
`345`	`345`	`operations: &mut [Operation<'a>],`
`346`	`346`	`) -> Result<(), Self::Error> {`
`347`		`- (*self).exec(address, operations)`
	`347`	`+ T::exec(self, address, operations)`
`348`	`348`	`}`
`349`	`349`	`}`
`350`	`350`
`@@ -380,7 +380,7 @@ pub mod blocking {`
`380`	`380`	`where`
`381`	`381`	`O: IntoIterator<Item = Operation<'a>>,`
`382`	`382`	`{`
`383`		`- (*self).exec_iter(address, operations)`
	`383`	`+ T::exec_iter(self, address, operations)`
`384`	`384`	`}`
`385`	`385`	`}`
`386`	`386`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,38 +112,38 @@ pub mod blocking {`
`112`	`112`	`type Duty = T::Duty;`
`113`	`113`
`114`	`114`	`fn disable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {`
`115`		`- (*self).disable(channel)`
	`115`	`+ T::disable(self, channel)`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`fn enable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {`
`119`		`- (*self).enable(channel)`
	`119`	`+ T::enable(self, channel)`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`fn get_period(&self) -> Result<Self::Time, Self::Error> {`
`123`		`- (**self).get_period()`
	`123`	`+ T::get_period(self)`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`fn get_duty(&self, channel: &Self::Channel) -> Result<Self::Duty, Self::Error> {`
`127`		`- (**self).get_duty(channel)`
	`127`	`+ T::get_duty(self, channel)`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {`
`131`		`- (**self).get_max_duty()`
	`131`	`+ T::get_max_duty(self)`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`fn set_duty(`
`135`	`135`	`&mut self,`
`136`	`136`	`channel: &Self::Channel,`
`137`	`137`	`duty: Self::Duty,`
`138`	`138`	`) -> Result<(), Self::Error> {`
`139`		`- (*self).set_duty(channel, duty)`
	`139`	`+ T::set_duty(self, channel, duty)`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`fn set_period<P>(&mut self, period: P) -> Result<(), Self::Error>`
`143`	`143`	`where`
`144`	`144`	`P: Into<Self::Time>,`
`145`	`145`	`{`
`146`		`- (*self).set_period(period)`
	`146`	`+ T::set_period(self, period)`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`@@ -185,23 +185,23 @@ pub mod blocking {`
`185`	`185`	`type Duty = T::Duty;`
`186`	`186`
`187`	`187`	`fn disable(&mut self) -> Result<(), Self::Error> {`
`188`		`- (*self).disable()`
	`188`	`+ T::disable(self)`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`fn enable(&mut self) -> Result<(), Self::Error> {`
`192`		`- (*self).enable()`
	`192`	`+ T::enable(self)`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`fn get_duty(&self) -> Result<Self::Duty, Self::Error> {`
`196`		`- (**self).get_duty()`
	`196`	`+ T::get_duty(self)`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {`
`200`		`- (**self).get_max_duty()`
	`200`	`+ T::get_max_duty(self)`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`fn set_duty(&mut self, duty: Self::Duty) -> Result<(), Self::Error> {`
`204`		`- (*self).set_duty(duty)`
	`204`	`+ T::set_duty(self, duty)`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,11 +88,11 @@ pub mod blocking {`
`88`	`88`	`type Count = T::Count;`
`89`	`89`
`90`	`90`	`fn count(&self) -> Result<Self::Count, Self::Error> {`
`91`		`- (*self).count()`
	`91`	`+ T::count(self)`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`fn direction(&self) -> Result<Direction, Self::Error> {`
`95`		`- (*self).direction()`
	`95`	`+ T::direction(self)`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ impl<T: Write<Word>, Word> Write<Word> for &mut T {`
`27`	`27`	`type Error = T::Error;`
`28`	`28`
`29`	`29`	`fn write(&mut self, buffer: &[Word]) -> Result<(), Self::Error> {`
`30`		`- (*self).write(buffer)`
	`30`	`+ T::write(self, buffer)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`fn flush(&mut self) -> Result<(), Self::Error> {`
`34`		`- (*self).flush()`
	`34`	`+ T::flush(self)`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl<T: Read<Word>, Word> Read<Word> for &mut T {`
`16`	`16`	`type Error = T::Error;`
`17`	`17`
`18`	`18`	`fn read(&mut self) -> nb::Result<Word, Self::Error> {`
`19`		`- (*self).read()`
	`19`	`+ T::read(self)`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
`@@ -36,10 +36,10 @@ impl<T: Write<Word>, Word> Write<Word> for &mut T {`
`36`	`36`	`type Error = T::Error;`
`37`	`37`
`38`	`38`	`fn write(&mut self, word: Word) -> nb::Result<(), Self::Error> {`
`39`		`- (*self).write(word)`
	`39`	`+ T::write(self, word)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`fn flush(&mut self) -> nb::Result<(), Self::Error> {`
`43`		`- (*self).flush()`
	`43`	`+ T::flush(self)`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ impl<T: Transfer<W>, W> Transfer<W> for &mut T {`
`19`	`19`	`type Error = T::Error;`
`20`	`20`
`21`	`21`	`fn transfer(&mut self, words: &mut [W]) -> Result<(), Self::Error> {`
`22`		`- (*self).transfer(words)`
	`22`	`+ T::transfer(self, words)`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`@@ -36,7 +36,7 @@ impl<T: Write<W>, W> Write<W> for &mut T {`
`36`	`36`	`type Error = T::Error;`
`37`	`37`
`38`	`38`	`fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {`
`39`		`- (*self).write(words)`
	`39`	`+ T::write(self, words)`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`@@ -58,7 +58,7 @@ impl<T: WriteIter<W>, W> WriteIter<W> for &mut T {`
`58`	`58`	`where`
`59`	`59`	`WI: IntoIterator<Item = W>,`
`60`	`60`	`{`
`61`		`- (*self).write_iter(words)`
	`61`	`+ T::write_iter(self, words)`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`@@ -87,6 +87,6 @@ impl<T: Transactional<W>, W: 'static> Transactional<W> for &mut T {`
`87`	`87`	`type Error = T::Error;`
`88`	`88`
`89`	`89`	`fn exec<'a>(&mut self, operations: &mut [Operation<'a, W>]) -> Result<(), Self::Error> {`
`90`		`- (*self).exec(operations)`
	`90`	`+ T::exec(self, operations)`
`91`	`91`	`}`
`92`	`92`	`}`