refactor: some minor changes for clearity

Author: koitococo

src/utils/hash.rs

@@ -55,7 +55,8 @@ pub enum HashError {
 pub async fn digest_for_file(path: &str, mut hasher: Box<dyn DynDigest + Send + Unpin>) -> Result<String, HashError> {
   let mut fd = File::open(path).await?;
   // for files smaller than 1MB we can read the whole file into memory
-  if fd.metadata().await.unwrap().len() < 1024 * 1024 {
+  let metadata = fd.metadata().await.map_err(HashError::IoError)?;
+  if metadata.len() < 1024 * 1024 {
     let mut buf = Vec::new();
     fd.read_to_end(&mut buf).await?;
     hasher.update(&buf);
@@ -110,7 +111,8 @@ pub async fn digests_for_file(
 ) -> Result<Vec<String>, HashError> {
   let mut fd = File::open(path).await?;
   // for files smaller than 1MB we can read the whole file into memory
-  if fd.metadata().await.unwrap().len() < 1024 * 1024 {
+  let metadata = fd.metadata().await.map_err(HashError::IoError)?;
+  if metadata.len() < 1024 * 1024 {
     let mut buf = Vec::new();
     fd.read_to_end(&mut buf).await?;
     for hasher in &mut hashers {

src/utils/states.rs

@@ -32,51 +32,41 @@ impl<Key, State> StateMap<Key, State> {
 
 impl<Key: Ord + Clone, State> States<Key, State> for StateMap<Key, State> {
   fn insert(&self, key: Key, item: State) -> bool {
-    let guard = self._inner.write();
-    if guard.is_err() {
+    let Ok(mut guard) = self._inner.write() else {
       return false;
-    }
-    let mut guard = guard.unwrap();
+    };
     guard.insert(key, Arc::new(item));
     true
   }
 
   fn get_arc(&self, key: &Key) -> Option<Arc<State>> {
-    let guard = self._inner.read();
-    if guard.is_err() {
+    let Ok(guard) = self._inner.read() else {
       return None;
-    }
-    let guard = guard.unwrap();
+    };
     guard.get(key).cloned()
   }
 
   fn remove(&self, key: &Key) {
-    let guard = self._inner.write();
-    if guard.is_err() {
+    let Ok(mut guard) = self._inner.write() else {
       return;
-    }
-    let mut guard = guard.unwrap();
+    };
     guard.remove(key);
   }
 
   fn list(&self) -> Vec<Key> {
-    let guard = self._inner.read();
-    if guard.is_err() {
+    let Ok(guard) = self._inner.read() else {
       return Vec::with_capacity(0);
-    }
-    let guard = guard.unwrap();
+    };
     guard.keys().cloned().collect()
   }
 }
 
 impl<Key: Ord + Clone, State> StateMap<Key, State> {
   pub fn try_insert_deferred_returning<F>(&self, key: Key, f: F) -> Option<Arc<State>>
   where F: FnOnce() -> State {
-    let guard = self._inner.write();
-    if guard.is_err() {
+    let Ok(mut guard) = self._inner.write() else {
       return None;
-    }
-    let mut guard = guard.unwrap();
+    };
     match guard.entry(key) {
       Entry::Vacant(vacant_entry) => {
         let val = Arc::new(f());