Remove explicit calls to as_ref/as_mut

These were flagged by `cargo clippy`:

    warning: this call to `as_ref` does nothing
    warning: this call to `as_mut` does nothing

examples/server.rs

@@ -91,7 +91,7 @@ fn main() {
             let client = match socket.recv() {
                 Ok((data, endpoint)) => {
                     debug!("udp:6969 recv data: {:?} from {}",
-                           str::from_utf8(data.as_ref()).unwrap(), endpoint);
+                           str::from_utf8(data).unwrap(), endpoint);
                     Some(endpoint)
                 }
                 Err(_) => None

src/iface/ethernet.rs

@@ -1510,7 +1510,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
         let tx_len = EthernetFrame::<&[u8]>::buffer_len(buffer_len);
         tx_token.consume(timestamp, tx_len, |tx_buffer| {
             debug_assert!(tx_buffer.as_ref().len() == tx_len);
-            let mut frame = EthernetFrame::new_unchecked(tx_buffer.as_mut());
+            let mut frame = EthernetFrame::new_unchecked(tx_buffer);
             frame.set_src_addr(self.ethernet_addr);
 
             f(frame);

src/socket/raw.rs

@@ -115,7 +115,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
         net_trace!("{}:{}:{}: buffer to send {} octets",
                    self.meta.handle, self.ip_version, self.ip_protocol,
                    packet_buf.len());
-        Ok(packet_buf.as_mut())
+        Ok(packet_buf)
     }
 
     /// Enqueue a packet to send, and fill it from a slice.
@@ -165,8 +165,8 @@ impl<'a, 'b> RawSocket<'a, 'b> {
         let header_len = ip_repr.buffer_len();
         let total_len  = header_len + payload.len();
         let packet_buf = self.rx_buffer.enqueue(total_len, ())?;
-        ip_repr.emit(&mut packet_buf.as_mut()[..header_len], &checksum_caps);
-        packet_buf.as_mut()[header_len..].copy_from_slice(payload);
+        ip_repr.emit(&mut packet_buf[..header_len], &checksum_caps);
+        packet_buf[header_len..].copy_from_slice(payload);
 
         net_trace!("{}:{}:{}: receiving {} octets",
                    self.meta.handle, self.ip_version, self.ip_protocol,
@@ -179,10 +179,10 @@ impl<'a, 'b> RawSocket<'a, 'b> {
             where F: FnOnce((IpRepr, &[u8])) -> Result<()> {
         fn prepare<'a>(protocol: IpProtocol, buffer: &'a mut [u8],
                    _checksum_caps: &ChecksumCapabilities) -> Result<(IpRepr, &'a [u8])> {
-            match IpVersion::of_packet(buffer.as_ref())? {
+            match IpVersion::of_packet(buffer)? {
                 #[cfg(feature = "proto-ipv4")]
                 IpVersion::Ipv4 => {
-                    let mut packet = Ipv4Packet::new_checked(buffer.as_mut())?;
+                    let mut packet = Ipv4Packet::new_checked(buffer)?;
                     if packet.protocol() != protocol { return Err(Error::Unaddressable) }
                     if _checksum_caps.ipv4.tx() {
                         packet.fill_checksum();
@@ -198,7 +198,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
                 }
                 #[cfg(feature = "proto-ipv6")]
                 IpVersion::Ipv6 => {
-                    let packet = Ipv6Packet::new_checked(buffer.as_mut())?;
+                    let packet = Ipv6Packet::new_checked(buffer)?;
                     if packet.next_header() != protocol { return Err(Error::Unaddressable) }
                     let packet = Ipv6Packet::new_unchecked(&*packet.into_inner());
                     let ipv6_repr = Ipv6Repr::parse(&packet)?;
@@ -213,7 +213,7 @@ impl<'a, 'b> RawSocket<'a, 'b> {
         let ip_protocol = self.ip_protocol;
         let ip_version  = self.ip_version;
         self.tx_buffer.dequeue_with(|&mut (), packet_buf| {
-            match prepare(ip_protocol, packet_buf.as_mut(), &checksum_caps) {
+            match prepare(ip_protocol, packet_buf, &checksum_caps) {
                 Ok((ip_repr, raw_packet)) => {
                     net_trace!("{}:{}:{}: sending {} octets",
                                handle, ip_version, ip_protocol,

src/wire/ip.rs

@@ -879,11 +879,11 @@ pub fn pretty_print_ip_payload<T: Into<Repr>>(f: &mut fmt::Formatter, indent: &m
         #[cfg(feature = "proto-ipv4")]
         Protocol::Icmp => {
             indent.increase(f)?;
-            Icmpv4Packet::<&[u8]>::pretty_print(&payload.as_ref(), f, indent)
+            Icmpv4Packet::<&[u8]>::pretty_print(&payload, f, indent)
         }
         Protocol::Udp => {
             indent.increase(f)?;
-            match UdpPacket::<&[u8]>::new_checked(payload.as_ref()) {
+            match UdpPacket::<&[u8]>::new_checked(payload) {
                 Err(err) => write!(f, "{}({})", indent, err),
                 Ok(udp_packet) => {
                     match UdpRepr::parse(&udp_packet, &repr.src_addr(),
@@ -901,7 +901,7 @@ pub fn pretty_print_ip_payload<T: Into<Repr>>(f: &mut fmt::Formatter, indent: &m
         }
         Protocol::Tcp => {
             indent.increase(f)?;
-            match TcpPacket::<&[u8]>::new_checked(payload.as_ref()) {
+            match TcpPacket::<&[u8]>::new_checked(payload) {
                 Err(err) => write!(f, "{}({})", indent, err),
                 Ok(tcp_packet) => {
                     match TcpRepr::parse(&tcp_packet, &repr.src_addr(),