Update Rust imports to match style guide

Author: stepchowfun

src/assertions.rs

@@ -58,7 +58,8 @@ macro_rules! assert_same {
 
 #[cfg(test)]
 mod tests {
-    use {crate::error::Error, std::fmt::Write};
+    use crate::error::Error;
+    use std::fmt::Write;
 
     #[test]
     #[should_panic(expected = "The expression was supposed to fail, but it succeeded.")]

src/de_bruijn.rs

@@ -1,14 +1,12 @@
-use {
-    crate::term::{
-        Term,
-        Variant::{
-            Application, Boolean, Difference, EqualTo, False, GreaterThan, GreaterThanOrEqualTo,
-            If, Integer, IntegerLiteral, Lambda, LessThan, LessThanOrEqualTo, Let, Negation, Pi,
-            Product, Quotient, Sum, True, Type, Unifier, Variable,
-        },
+use crate::term::{
+    Term,
+    Variant::{
+        Application, Boolean, Difference, EqualTo, False, GreaterThan, GreaterThanOrEqualTo, If,
+        Integer, IntegerLiteral, Lambda, LessThan, LessThanOrEqualTo, Let, Negation, Pi, Product,
+        Quotient, Sum, True, Type, Unifier, Variable,
     },
-    std::{cell::RefCell, convert::TryFrom, rc::Rc},
 };
+use std::{cell::RefCell, convert::TryFrom, rc::Rc};
 
 // Shifting refers to adjusting the De Bruijn indices of free variables. A cutoff determines which
 // variables are considered free. This function is used to raise or lower a term into a different
@@ -429,23 +427,21 @@ pub fn open<'a>(
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::{
-            assert_same,
-            de_bruijn::{open, signed_shift, unsigned_shift},
-            term::{
-                Term,
-                Variant::{
-                    Application, Boolean, Difference, EqualTo, False, GreaterThan,
-                    GreaterThanOrEqualTo, If, Integer, IntegerLiteral, Lambda, LessThan,
-                    LessThanOrEqualTo, Let, Negation, Pi, Product, Quotient, Sum, True, Type,
-                    Unifier, Variable,
-                },
+    use crate::{
+        assert_same,
+        de_bruijn::{open, signed_shift, unsigned_shift},
+        term::{
+            Term,
+            Variant::{
+                Application, Boolean, Difference, EqualTo, False, GreaterThan,
+                GreaterThanOrEqualTo, If, Integer, IntegerLiteral, Lambda, LessThan,
+                LessThanOrEqualTo, Let, Negation, Pi, Product, Quotient, Sum, True, Type, Unifier,
+                Variable,
             },
         },
-        num_bigint::ToBigInt,
-        std::{cell::RefCell, rc::Rc},
     };
+    use num_bigint::ToBigInt;
+    use std::{cell::RefCell, rc::Rc};
 
     #[test]
     fn signed_shift_unifier_none_valid() {

src/equality.rs

@@ -1,18 +1,15 @@
-use {
-    crate::{
-        de_bruijn::unsigned_shift,
-        term::{
-            Term,
-            Variant::{
-                Application, Boolean, Difference, EqualTo, False, GreaterThan,
-                GreaterThanOrEqualTo, If, Integer, IntegerLiteral, Lambda, LessThan,
-                LessThanOrEqualTo, Let, Negation, Pi, Product, Quotient, Sum, True, Type, Unifier,
-                Variable,
-            },
+use crate::{
+    de_bruijn::unsigned_shift,
+    term::{
+        Term,
+        Variant::{
+            Application, Boolean, Difference, EqualTo, False, GreaterThan, GreaterThanOrEqualTo,
+            If, Integer, IntegerLiteral, Lambda, LessThan, LessThanOrEqualTo, Let, Negation, Pi,
+            Product, Quotient, Sum, True, Type, Unifier, Variable,
         },
     },
-    std::rc::Rc,
 };
+use std::rc::Rc;
 
 // Check if two terms are equal up to alpha conversion. Type annotations are not checked.
 #[allow(clippy::similar_names)]
@@ -154,18 +151,16 @@ pub fn syntactically_equal<'a>(term1: &Term<'a>, term2: &Term<'a>) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::{
-            equality::syntactically_equal,
-            parser::parse,
-            term::{
-                Term,
-                Variant::{Unifier, Variable},
-            },
-            tokenizer::tokenize,
+    use crate::{
+        equality::syntactically_equal,
+        parser::parse,
+        term::{
+            Term,
+            Variant::{Unifier, Variable},
         },
-        std::{cell::RefCell, rc::Rc},
+        tokenizer::tokenize,
     };
+    use std::{cell::RefCell, rc::Rc};
 
     #[test]
     fn syntactically_equal_unifier_left() {

src/error.rs

@@ -1,13 +1,11 @@
-use {
-    crate::format::CodeStr,
-    colored::{Colorize, control::SHOULD_COLORIZE},
-    pad::{Alignment, PadStr},
-    std::{
-        cmp::{max, min},
-        error, fmt,
-        path::Path,
-        rc::Rc,
-    },
+use crate::format::CodeStr;
+use colored::{Colorize, control::SHOULD_COLORIZE};
+use pad::{Alignment, PadStr};
+use std::{
+    cmp::{max, min},
+    error, fmt,
+    path::Path,
+    rc::Rc,
 };
 
 // This is the primary error type we'll be using everywhere.
@@ -207,13 +205,11 @@ pub fn listing(source_contents: &str, source_range: SourceRange) -> String {
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::{
-            assert_same,
-            error::{Error, SourceRange, listing, throw},
-        },
-        std::{path::Path, rc::Rc},
+    use crate::{
+        assert_same,
+        error::{Error, SourceRange, listing, throw},
     };
+    use std::{path::Path, rc::Rc};
 
     #[test]
     fn error_no_reason_display() {

src/evaluator.rs

@@ -1,20 +1,17 @@
-use {
-    crate::{
-        de_bruijn::{open, unsigned_shift},
-        error::Error,
-        format::CodeStr,
-        term::{
-            Term,
-            Variant::{
-                Application, Boolean, Difference, EqualTo, False, GreaterThan,
-                GreaterThanOrEqualTo, If, Integer, IntegerLiteral, Lambda, LessThan,
-                LessThanOrEqualTo, Let, Negation, Pi, Product, Quotient, Sum, True, Type, Unifier,
-                Variable,
-            },
+use crate::{
+    de_bruijn::{open, unsigned_shift},
+    error::Error,
+    format::CodeStr,
+    term::{
+        Term,
+        Variant::{
+            Application, Boolean, Difference, EqualTo, False, GreaterThan, GreaterThanOrEqualTo,
+            If, Integer, IntegerLiteral, Lambda, LessThan, LessThanOrEqualTo, Let, Negation, Pi,
+            Product, Quotient, Sum, True, Type, Unifier, Variable,
         },
     },
-    std::{iter::once, rc::Rc},
 };
+use std::{iter::once, rc::Rc};
 
 // This function evaluates a term using a call-by-value strategy.
 pub fn evaluate<'a>(term: &Term<'a>) -> Result<Term<'a>, Error> {
@@ -636,24 +633,22 @@ pub fn is_value(term: &Term) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::{
-            assert_same,
-            error::SourceRange,
-            evaluator::evaluate,
-            parser::parse,
-            term::{
-                Term,
-                Variant::{
-                    Application, Boolean, False, Integer, IntegerLiteral, Lambda, Pi, True, Type,
-                    Variable,
-                },
+    use crate::{
+        assert_same,
+        error::SourceRange,
+        evaluator::evaluate,
+        parser::parse,
+        term::{
+            Term,
+            Variant::{
+                Application, Boolean, False, Integer, IntegerLiteral, Lambda, Pi, True, Type,
+                Variable,
             },
-            tokenizer::tokenize,
         },
-        num_bigint::ToBigInt,
-        std::rc::Rc,
+        tokenizer::tokenize,
     };
+    use num_bigint::ToBigInt;
+    use std::rc::Rc;
 
     #[test]
     fn evaluate_type() {

src/main.rs

@@ -12,19 +12,17 @@ mod tokenizer;
 mod type_checker;
 mod unifier;
 
-use {
-    crate::{
-        error::{Error, throw},
-        evaluator::evaluate,
-        format::CodeStr,
-        parser::parse,
-        tokenizer::tokenize,
-        type_checker::type_check,
-    },
-    clap::{ArgAction, Args, CommandFactory, Parser, Subcommand as ClapSubcommand},
-    clap_complete::{Shell, generate},
-    std::{fs::read_to_string, io::stdout, path::Path, process::exit, thread},
+use crate::{
+    error::{Error, throw},
+    evaluator::evaluate,
+    format::CodeStr,
+    parser::parse,
+    tokenizer::tokenize,
+    type_checker::type_check,
 };
+use clap::{ArgAction, Args, CommandFactory, Parser, Subcommand as ClapSubcommand};
+use clap_complete::{Shell, generate};
+use std::{fs::read_to_string, io::stdout, path::Path, process::exit, thread};
 
 // The name of the program binary
 const BIN_NAME: &str = "gram";

src/normalizer.rs

@@ -1,18 +1,15 @@
-use {
-    crate::{
-        de_bruijn::{open, unsigned_shift},
-        term::{
-            Term,
-            Variant::{
-                Application, Boolean, Difference, EqualTo, False, GreaterThan,
-                GreaterThanOrEqualTo, If, Integer, IntegerLiteral, Lambda, LessThan,
-                LessThanOrEqualTo, Let, Negation, Pi, Product, Quotient, Sum, True, Type, Unifier,
-                Variable,
-            },
+use crate::{
+    de_bruijn::{open, unsigned_shift},
+    term::{
+        Term,
+        Variant::{
+            Application, Boolean, Difference, EqualTo, False, GreaterThan, GreaterThanOrEqualTo,
+            If, Integer, IntegerLiteral, Lambda, LessThan, LessThanOrEqualTo, Let, Negation, Pi,
+            Product, Quotient, Sum, True, Type, Unifier, Variable,
         },
     },
-    std::rc::Rc,
 };
+use std::rc::Rc;
 
 // This function reduces a term to weak head normal form using normal order reduction. Invariant:
 // when this function is finished, the context is left unmodified.
@@ -412,24 +409,22 @@ pub fn normalize_weak_head<'a>(
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::{
-            assert_same,
-            error::SourceRange,
-            normalizer::normalize_weak_head,
-            parser::parse,
-            term::{
-                Term,
-                Variant::{
-                    Application, Boolean, False, Integer, IntegerLiteral, Lambda, Pi, True, Type,
-                    Variable,
-                },
+    use crate::{
+        assert_same,
+        error::SourceRange,
+        normalizer::normalize_weak_head,
+        parser::parse,
+        term::{
+            Term,
+            Variant::{
+                Application, Boolean, False, Integer, IntegerLiteral, Lambda, Pi, True, Type,
+                Variable,
             },
-            tokenizer::tokenize,
         },
-        num_bigint::ToBigInt,
-        std::rc::Rc,
+        tokenizer::tokenize,
     };
+    use num_bigint::ToBigInt;
+    use std::rc::Rc;
 
     #[test]
     fn normalize_weak_head_type() {