ehal spi transfer;; expanded

x.rs

        /// Blocking transfer
        pub mod transfer {
            /// Default implementation of `blocking::spi::Transfer<W>` for implementers of
            /// `spi::FullDuplex<W>`
            pub trait Default<W>: ::spi::FullDuplex<W> { }
            impl <W, S> ::blocking::spi::Transfer<W> for S where
             S: Default<W>, W: Clone {
                type
                Error
                =
                S::Error;
                fn transfer<'w>(&mut self, words: &'w mut [W])
                 -> Result<&'w [W], S::Error> {
                    for word in words.iter_mut() {
                        loop  {

                            #[allow(unreachable_patterns)]
                            match self.send(word.clone()) {
                                Err(::nb::Error::Other(e)) => {

                                    #[allow(unreachable_code)]
                                    break Err(e)
                                }
                                Err(::nb::Error::WouldBlock) => { }
                                Ok(x) => break Ok(x) ,
                            }
                        }?;
                        *word =
                            loop  {

                                #[allow(unreachable_patterns)]
                                match self.read() {
                                    Err(::nb::Error::Other(e)) => {

                                        #[allow(unreachable_code)]
                                        break Err(e)
                                    }
                                    Err(::nb::Error::WouldBlock) => { }
                                    Ok(x) => break Ok(x) ,
                                }
                            }?;
                    }
                    Ok(words)
                }
            }
        }