From bf533c58ed908dcee875087f2e9fbd42c0d8fa2c Mon Sep 17 00:00:00 2001
From: Serge Latyntcev <dnsl48@gmail.com>
Date: Sun, 11 Feb 2024 15:05:41 +1300
Subject: [PATCH] chore(clippy): fix clippy warnings

---
 src/decimal/mod.rs      | 30 ++++++++++++++----------------
 src/fraction/display.rs | 41 ++++++++++++++++++++++-------------------
 2 files changed, 36 insertions(+), 35 deletions(-)

diff --git a/src/decimal/mod.rs b/src/decimal/mod.rs
index 9961ba30..1e967ab7 100644
--- a/src/decimal/mod.rs
+++ b/src/decimal/mod.rs
@@ -407,38 +407,36 @@ where
 
                             let mut precision: usize = 0;
                             loop {
-                                s_state = match division::divide_rem_resume(
+                                s_state = if let Ok(s) = division::divide_rem_resume(
                                     s_state.take().unwrap(),
                                     |s, d| {
                                         s_digit = d;
                                         Ok(Err(s))
                                     },
                                 ) {
-                                    Ok(s) => {
-                                        if s.remainder.is_zero() {
-                                            None
-                                        } else {
-                                            Some(s)
-                                        }
+                                    if s.remainder.is_zero() {
+                                        None
+                                    } else {
+                                        Some(s)
                                     }
-                                    Err(_) => return false,
+                                } else {
+                                    return false;
                                 };
 
-                                o_state = match division::divide_rem_resume(
+                                o_state = if let Ok(s) = division::divide_rem_resume(
                                     o_state.take().unwrap(),
                                     |s, d| {
                                         o_digit = d;
                                         Ok(Err(s))
                                     },
                                 ) {
-                                    Ok(s) => {
-                                        if s.remainder.is_zero() {
-                                            None
-                                        } else {
-                                            Some(s)
-                                        }
+                                    if s.remainder.is_zero() {
+                                        None
+                                    } else {
+                                        Some(s)
                                     }
-                                    Err(_) => return false,
+                                } else {
+                                    return false
                                 };
 
                                 if s_digit != o_digit {
diff --git a/src/fraction/display.rs b/src/fraction/display.rs
index 4d3cb4bb..90c2b4e6 100644
--- a/src/fraction/display.rs
+++ b/src/fraction/display.rs
@@ -299,39 +299,42 @@ where
                 let mut length = 0;
 
                 if let Some(precision) = format.precision() {
-                    match division::divide_to_callback(
+                    let callback = |digit| {
+                        length += 1;
+                        division::write_digit(buffer, digit)
+                    };
+
+                    if division::divide_to_callback(
                         numer,
                         denom,
                         *precision,
                         format.alternate(),
-                        |digit| {
-                            length += 1;
-                            division::write_digit(buffer, digit)
-                        },
-                    ) {
-                        Ok(_) => Ok(()),
-                        Err(_) => Err(fmt::Error),
-                    }?;
+                        callback,
+                    ).is_err() {
+                        return Err(fmt::Error);
+                    }
                 } else {
-                    match division::divide_to_callback(numer, T::one(), 0, false, |digit| {
+                    let callback = |digit| {
                         length += 1;
                         division::write_digit(buffer, digit)
-                    }) {
-                        Ok(_) => Ok(()),
-                        Err(_) => Err(fmt::Error),
-                    }?;
+                    };
+
+                    if division::divide_to_callback(numer, T::one(), 0, false, callback).is_err() {
+                        return Err(fmt::Error);
+                    }
 
                     if !ratio.numer().is_zero() && !ratio.denom().is_one() {
                         length += 1;
                         buffer.write_char('/')?;
 
-                        match division::divide_to_callback(denom, T::one(), 0, false, |digit| {
+                        let callback = |digit| {
                             length += 1;
                             division::write_digit(buffer, digit)
-                        }) {
-                            Ok(_) => Ok(()),
-                            Err(_) => Err(fmt::Error),
-                        }?;
+                        };
+
+                        if division::divide_to_callback(denom, T::one(), 0, false, callback).is_err() {
+                            return Err(fmt::Error)
+                        };
                     }
                 }