From fd8e5acd57aafedc32341fc93c4f10d8331fc30e Mon Sep 17 00:00:00 2001
From: Roy Ivy III <rivy.dev@gmail.com>
Date: Thu, 26 Dec 2019 10:53:12 -0600
Subject: [PATCH] refactor/polish ~ fix `cargo clippy` complaints (loop/match
 => while let)

---
 src/printf/tokenize/num_format/num_format.rs |  13 +-
 src/seq/seq.rs                               | 193 +++++++++----------
 2 files changed, 98 insertions(+), 108 deletions(-)

diff --git a/src/printf/tokenize/num_format/num_format.rs b/src/printf/tokenize/num_format/num_format.rs
index 391548464..b0a4a3f4b 100644
--- a/src/printf/tokenize/num_format/num_format.rs
+++ b/src/printf/tokenize/num_format/num_format.rs
@@ -90,16 +90,9 @@ fn get_inprefix(str_in: &str, field_type: &FieldType) -> InPrefix {
     let mut topchar = str_it.next();
     // skip spaces and ensure topchar is the first non-space char
     // (or None if none exists)
-    loop {
-        match topchar {
-            Some(' ') => {
-                ret.offset += 1;
-                topchar = str_it.next();
-            }
-            _ => {
-                break;
-            }
-        }
+    while let Some(' ') = topchar {
+        ret.offset += 1;
+        topchar = str_it.next();
     }
     // parse sign
     match topchar {
diff --git a/src/seq/seq.rs b/src/seq/seq.rs
index a3d1b55b3..52a171a6e 100644
--- a/src/seq/seq.rs
+++ b/src/seq/seq.rs
@@ -41,106 +41,103 @@ fn escape_sequences(s: &str) -> String {
 fn parse_options(args: Vec<String>, options: &mut SeqOptions) -> Result<Vec<String>, i32> {
     let mut seq_args = vec![];
     let mut iter = args.into_iter().skip(1);
-    loop {
-        match iter.next() {
-            Some(arg) => match &arg[..] {
-                "--help" | "-h" => {
-                    print_help();
-                    return Err(0);
-                }
-                "--version" | "-V" => {
-                    print_version();
-                    return Err(0);
-                }
-                "-s" | "--separator" => match iter.next() {
-                    Some(sep) => options.separator = sep,
-                    None => {
-                        show_error!("expected a separator after {}", arg);
-                        return Err(1);
-                    }
-                },
-                "-t" | "--terminator" => match iter.next() {
-                    Some(term) => options.terminator = Some(term),
-                    None => {
-                        show_error!("expected a terminator after '{}'", arg);
-                        return Err(1);
-                    }
-                },
-                "-w" | "--widths" => options.widths = true,
-                "--" => {
-                    seq_args.extend(iter);
-                    break;
-                }
-                _ => {
-                    if arg.len() > 1 && arg.starts_with('-') {
-                        let argptr: *const String = &arg; // escape from the borrow checker
-                        let mut chiter = unsafe { &(*argptr)[..] }.chars().skip(1);
-                        let mut ch = ' ';
-                        while match chiter.next() {
-                            Some(m) => {
-                                ch = m;
-                                true
-                            }
-                            None => false,
-                        } {
-                            match ch {
-                                'h' => {
-                                    print_help();
-                                    return Err(0);
-                                }
-                                'V' => {
-                                    print_version();
-                                    return Err(0);
-                                }
-                                's' => match iter.next() {
-                                    Some(sep) => {
-                                        options.separator = sep;
-                                        let next = chiter.next();
-                                        if next.is_some() {
-                                            show_error!(
-                                                "unexpected character ('{}')",
-                                                next.unwrap()
-                                            );
-                                            return Err(1);
-                                        }
-                                    }
-                                    None => {
-                                        show_error!("expected a separator after {}", arg);
-                                        return Err(1);
-                                    }
-                                },
-                                't' => match iter.next() {
-                                    Some(term) => {
-                                        options.terminator = Some(term);
-                                        let next = chiter.next();
-                                        if next.is_some() {
-                                            show_error!(
-                                                "unexpected character ('{}')",
-                                                next.unwrap()
-                                            );
-                                            return Err(1);
-                                        }
-                                    }
-                                    None => {
-                                        show_error!("expected a terminator after {}", arg);
-                                        return Err(1);
-                                    }
-                                },
-                                'w' => options.widths = true,
-                                _ => {
-                                    seq_args.push(arg);
-                                    break;
-                                }
-                            }
-                        }
-                    } else {
-                        seq_args.push(arg);
-                    }
+    while let Some(arg) = iter.next() {
+        match &arg[..] {
+            "--help" | "-h" => {
+                print_help();
+                return Err(0);
+            }
+            "--version" | "-V" => {
+                print_version();
+                return Err(0);
+            }
+            "-s" | "--separator" => match iter.next() {
+                Some(sep) => options.separator = sep,
+                None => {
+                    show_error!("expected a separator after {}", arg);
+                    return Err(1);
                 }
             },
-            None => break,
-        }
-    }
+            "-t" | "--terminator" => match iter.next() {
+                Some(term) => options.terminator = Some(term),
+                None => {
+                    show_error!("expected a terminator after '{}'", arg);
+                    return Err(1);
+                }
+            },
+            "-w" | "--widths" => options.widths = true,
+            "--" => {
+                seq_args.extend(iter);
+                break;
+            }
+            _ => {
+                if arg.len() > 1 && arg.starts_with('-') {
+                    let argptr: *const String = &arg; // escape from the borrow checker
+                    let mut chiter = unsafe { &(*argptr)[..] }.chars().skip(1);
+                    let mut ch = ' ';
+                    while match chiter.next() {
+                        Some(m) => {
+                            ch = m;
+                            true
+                        }
+                        None => false,
+                    } {
+                        match ch {
+                            'h' => {
+                                print_help();
+                                return Err(0);
+                            }
+                            'V' => {
+                                print_version();
+                                return Err(0);
+                            }
+                            's' => match iter.next() {
+                                Some(sep) => {
+                                    options.separator = sep;
+                                    let next = chiter.next();
+                                    if next.is_some() {
+                                        show_error!(
+                                            "unexpected character ('{}')",
+                                            next.unwrap()
+                                        );
+                                        return Err(1);
+                                    }
+                                }
+                                None => {
+                                    show_error!("expected a separator after {}", arg);
+                                    return Err(1);
+                                }
+                            },
+                            't' => match iter.next() {
+                                Some(term) => {
+                                    options.terminator = Some(term);
+                                    let next = chiter.next();
+                                    if next.is_some() {
+                                        show_error!(
+                                            "unexpected character ('{}')",
+                                            next.unwrap()
+                                        );
+                                        return Err(1);
+                                    }
+                                }
+                                None => {
+                                    show_error!("expected a terminator after {}", arg);
+                                    return Err(1);
+                                }
+                            },
+                            'w' => options.widths = true,
+                            _ => {
+                                seq_args.push(arg);
+                                break;
+                            }
+                        }
+                    }
+                } else {
+                    seq_args.push(arg);
+                }
+            }
+        };
+    };
     Ok(seq_args)
 }