Made changes indicated by clippy.

crates/node/src/main.rs

@@ -220,11 +220,8 @@ impl<'s> TryFrom<&'s str> for Path {
         let mut pairs = string.char_indices();
         let mut components = Vec::new();
         let mut last_end = 0;
-        loop {
-            let (start, end) = match pairs.next() {
-                Some((start, c)) => (start, Path::component_end(start, c, &mut pairs)?),
-                None => break
-            };
+        while let Some((start, c)) = pairs.next() {
+            let end = Path::component_end(start, c, &mut pairs)?;
             last_end = end;
             let slice = &string[start..end];
             components.push(slice.to_string());

crates/serde-block-tree/src/de.rs

@@ -11,16 +11,16 @@ use serde::de::{
     IntoDeserializer
 };
 
+// This lint is disabled because deserializing from a `&[u8]` is handled by `read_from`.
+#[allow(clippy::ptr_arg)]
 pub fn from_vec<T: DeserializeOwned>(vec: &Vec<u8>) -> Result<T> {
     let mut slice = vec.as_slice();
-    let result = read_from(&mut slice);
-    result
+    read_from(&mut slice)
 }
 
 pub fn read_from<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
     let mut de = Deserializer::new(read);
-    let result = Deserialize::deserialize(&mut de);
-    result
+    Deserialize::deserialize(&mut de)
 }
 
 pub struct Deserializer<'de, T: Read + ?Sized> {
@@ -28,7 +28,7 @@ pub struct Deserializer<'de, T: Read + ?Sized> {
 }
 
 fn try_from<TSource, TDest: TryFrom<TSource>>(value: TSource) -> Result<TDest> {
-    let cast = TDest::try_from(value).or_else(|_| Err(Error::TypeConversion))?;
+    let cast = TDest::try_from(value).map_err(|_| Error::TypeConversion)?;
     Ok(cast)
 }
 
@@ -89,11 +89,11 @@ fn char_from_utf8(buf: &[u8]) -> Result<char> {
 
 impl<'de, T: Read + ?Sized> Deserializer<'de, T> {
     pub fn new(input: &'de mut T) -> Self {
-        Deserializer { input: input }
+        Deserializer { input }
     }
 
     fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
-        self.input.read_exact(buf).or_else(|e| Err(Error::Io(e)))?;
+        self.input.read_exact(buf).map_err(Error::Io)?;
         Ok(())
     }
 
@@ -150,7 +150,7 @@ impl<'de, T: Read + ?Sized> Deserializer<'de, T> {
 
     fn read_string(&mut self) -> Result<String> {
         let vec = self.read_vec()?;
-        let value = String::from_utf8(vec).or_else(|_| Err(Error::TypeConversion))?;
+        let value = String::from_utf8(vec).map_err(|_| Error::TypeConversion)?;
         Ok(value)
     }
 }

crates/serde-block-tree/src/error.rs

@@ -58,6 +58,6 @@ pub trait MapError<T> {
 
 impl<T> MapError<T> for std::io::Result<T> {
     fn map_error(self) -> Result<T> {
-        self.or_else(|err| Result::Err(Error::Io(err)))
+        self.map_err(Error::Io)
     }
 }

crates/serde-block-tree/src/ser.rs

@@ -37,14 +37,13 @@ pub fn to_vec<T: Serialize + ?Sized>(value: &T) -> Result<Vec<u8>> {
 
 pub fn write_to<T: Serialize + ?Sized, W: Write>(value: &T, write: &mut W) -> Result<()> {
     let mut serializer = Serializer::new(write);
-    let result = value.serialize(&mut serializer);
-    result
+    value.serialize(&mut serializer)
 }
 
 fn try_convert(len: Option<usize>) -> Result<u32> {
     match len {
         Some(count) => {
-            let length = u32::try_from(count).or_else(|_| Err(Error::SequenceTooLong(count)))?;
+            let length = u32::try_from(count).map_err(|_| Error::SequenceTooLong(count))?;
             Ok(length)
         },
         None => Err(Error::UnknownLength),
@@ -52,7 +51,7 @@ fn try_convert(len: Option<usize>) -> Result<u32> {
 }
 
 fn convert_variant_index(index: u32) -> Result<u16> {
-    u16::try_from(index).or_else(|_| Err(Error::TooManyVariants(index)))
+    u16::try_from(index).map_err(|_| Error::TooManyVariants(index))
 }
 
 impl<'a, 'w, T: Write> ser::Serializer for &'a mut Serializer<'w, T> {