chore: format using GA_HAT rules

Author: SergioRibera

src/main.rs

@@ -51,7 +51,7 @@ macro_rules! ipsum {
 
 // ----------------------------------------------------------------------------
 lorem!(
-        const _: u8 = 0;
+    const _: u8 = 0;
 );
 ipsum!(
     const _: u8 = 0;
@@ -78,7 +78,11 @@ pub struct FieldAlign {
 }
 
 #[derive(Default, Debug, Serialize, Deserialize)]
-pub struct Foo { x: i32, y: i32, z: i32 }
+pub struct Foo {
+    x: i32,
+    y: i32,
+    z: i32,
+}
 
 #[derive(Default, Debug, Serialize, Deserialize)]
 pub struct Bar {
@@ -88,23 +92,21 @@ pub struct Bar {
 }
 
 // ----------------------------------------------------------------------------
-pub fn generic_compressed<Ipsum: Display+Debug=usize>() {}
+pub fn generic_compressed<Ipsum: Display + Debug = usize>() {}
 pub fn generic_wide<Ipsum: Display + Debug = usize>() {}
 
 pub trait LoremTrait<T> {}
 
-impl<T> LoremTrait<T> for Vec<T>
-where
-    Option<T>: Clone,
-{
-}
+impl<T> LoremTrait<T> for Vec<T> where Option<T>: Clone {}
 
 impl<T> LoremTrait<T> for std::collections::VecDeque<T> where Option<T>: Clone {}
 
 struct DummyIter;
 impl Iterator for DummyIter {
     const SIZE: usize = 0123456789;
-    fn next(&mut self) -> Option<Self::Item> { None }
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
     type Item = i32;
 }
 
@@ -122,7 +124,9 @@ impl Iterator for DummyIter {
 /// );
 /// # fn add_one(x: i32) -> i32 { x + 1 }
 /// ```
-pub fn add_one(x: i32) -> i32 { x + 1 }
+pub fn add_one(x: i32) -> i32 {
+    x + 1
+}
 
 // ----------------------------------------------------------------------------
 /* This is a block comment that rustfmt can optionally convert into a line
@@ -144,17 +148,29 @@ fn ranges_demo() {
 }
 
 // ----------------------------------------------------------------------------
-const HEXES: [u64; 5] = [0x0000_0000_0000_0000, 0xAAAA_AAAA_AAAA_AAAA, 0xbbbb_bbbb_bbbb_bbbb, 0xCCCC_CCCC_CCCC_CCCC, 0xDDDD_DDDD_DDDD_DDDD];
+const HEXES: [u64; 5] = [
+    0x0000_0000_0000_0000,
+    0xAAAA_AAAA_AAAA_AAAA,
+    0xbbbb_bbbb_bbbb_bbbb,
+    0xCCCC_CCCC_CCCC_CCCC,
+    0xDDDD_DDDD_DDDD_DDDD,
+];
 
 // ----------------------------------------------------------------------------
 const LONG_STR: &str = "ipsum dolor sit amet consectetur adipiscing elit lorem ipsum dolor sit amet consectetur adipiscing";
 
 // ----------------------------------------------------------------------------
 fn make_foo() -> Foo {
-    let x = 1; let y = 2; let z = 3;
+    let x = 1;
+    let y = 2;
+    let z = 3;
     let a = Foo { x, y, z }; // shorthand
     let b = Foo { x: x, y: y, z: z }; // no shorthand
-    if x > 0 { a } else { b }
+    if x > 0 {
+        a
+    } else {
+        b
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -168,11 +184,16 @@ fn overflow_demo() {
         param
     });
 
-    foo(ctx, Bar { ipsum: 1, dolor: 2, sit: 3 });
+    foo(
+        ctx,
+        Bar {
+            ipsum: 1,
+            dolor: 2,
+            sit: 3,
+        },
+    );
 
-    foo(ctx, &[
-        1, 2, 3, 4, 5,
-    ]);
+    foo(ctx, &[1, 2, 3, 4, 5]);
 
     foo(ctx, vec![1, 2, 3, 4, 5]);
 }
@@ -185,7 +206,7 @@ fn match_and_closure_demo(x: i32) {
     });
 
     match x {
-        | 0 | 1 => println!("small"),
+        0 | 1 => println!("small"),
         2 => {
             println!("two");
         }
@@ -195,18 +216,28 @@ fn match_and_closure_demo(x: i32) {
 }
 
 // ----------------------------------------------------------------------------
-fn single_line_things() -> i32 { 42 }
+fn single_line_things() -> i32 {
+    42
+}
 
 fn let_else_demo() {
     let opt = Some(10);
     let Some(v) = opt else { return };
-    if v > 5 { println!("gt5") } else { println!("le5") }
+    if v > 5 {
+        println!("gt5")
+    } else {
+        println!("le5")
+    }
 }
 
-fn return_semicolon() -> i32 { return 0; }
+fn return_semicolon() -> i32 {
+    return 0;
+}
 
 // ----------------------------------------------------------------------------
-fn nested_parens() { (((((println!("nested")))))); }
+fn nested_parens() {
+    (println!("nested"));
+}
 
 // ----------------------------------------------------------------------------
 fn try_demo() -> Result<(), io::Error> {
@@ -223,32 +254,32 @@ fn try_demo() -> Result<(), io::Error> {
 pub struct DocAttrItem;
 
 // ----------------------------------------------------------------------------
-#[cfg(any())] use std::marker::PhantomData;
+#[cfg(any())]
+use std::marker::PhantomData;
 
 // ----------------------------------------------------------------------------
 #[allow(clippy::too_many_arguments)]
-fn many_args(
-    a: i32,
-    b: i32,
-    c: i32,
-    d: i32,
-    e: i32,
-    f: i32,
-) -> i32 { a + b + c + d + e + f }
+fn many_args(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32) -> i32 {
+    a + b + c + d + e + f
+}
 
 fn destructuring() {
     let Foo { x, y, z } = Foo { x: 1, y: 2, z: 3 };
 }
 
 // ----------------------------------------------------------------------------
 fn spacing_demo<T: Eq>(t: T) {
-    let _lorem: Bar = Bar { ipsum: 1, dolor: 2, sit: 3 };
+    let _lorem: Bar = Bar {
+        ipsum: 1,
+        dolor: 2,
+        sit: 3,
+    };
 }
 
 // ----------------------------------------------------------------------------
 mod reorder_demo {
-    use std::time::{Duration, SystemTime};
     use std::cmp::{Ordering, Reverse};
+    use std::time::{Duration, SystemTime};
     use std::{mem, ptr};
 }
 
@@ -267,10 +298,18 @@ fn main() {
     let _hex_sum = HEXES.iter().sum::<u64>();
 
     // ----------------------------------------------------------
-    let _bar = Bar { ipsum: 10, dolor: 20, sit: 30 };
+    let _bar = Bar {
+        ipsum: 10,
+        dolor: 20,
+        sit: 30,
+    };
 
     // ----------------------------------------------------------
-    let _fa = FieldAlign { x: 1, yy: 2, zzz: 3 };
+    let _fa = FieldAlign {
+        x: 1,
+        yy: 2,
+        zzz: 3,
+    };
 
     // ----------------------------------------------------------
     nested_parens();
@@ -279,5 +318,8 @@ fn main() {
     let _arr = [1, 2, 3, 1234567890];
 
     // ----------------------------------------------------------
-    let _v = (0..10).map(|x| x + 1).filter(|x| x % 2 == 0).collect::<Vec<_>>();
+    let _v = (0..10)
+        .map(|x| x + 1)
+        .filter(|x| x % 2 == 0)
+        .collect::<Vec<_>>();
 }