fixed alignment in _rust/Types

sheets/_rust/Types

@@ -1,72 +1,72 @@
-    // Struct
-    struct Point {
-        x: i32,
-        y: i32,
-    }
-    let origin: Point = Point { x: 0, y: 0 };
+// Struct
+struct Point {
+    x: i32,
+    y: i32,
+}
+let origin: Point = Point { x: 0, y: 0 };
 
-    // A struct with unnamed fields, called a ‘tuple struct’
-    struct Point2(i32, i32);
-    let origin2 = Point2(0, 0);
+// A struct with unnamed fields, called a ‘tuple struct’
+struct Point2(i32, i32);
+let origin2 = Point2(0, 0);
 
-    // Basic C-like enum
-    enum Direction {
-        Left,
-        Right,
-        Up,
-        Down,
-    }
-    let up = Direction::Up;
+// Basic C-like enum
+enum Direction {
+    Left,
+    Right,
+    Up,
+    Down,
+}
+let up = Direction::Up;
 
-    // Enum with fields
-    enum OptionalI32 {
-        AnI32(i32),
-        Nothing,
-    }
-    let two: OptionalI32 = OptionalI32::AnI32(2);
-    let nothing = OptionalI32::Nothing;
+// Enum with fields
+enum OptionalI32 {
+    AnI32(i32),
+    Nothing,
+}
+let two: OptionalI32 = OptionalI32::AnI32(2);
+let nothing = OptionalI32::Nothing;
 
-    // Generics //
-    struct Foo<T> { bar: T }
-    //
-    // This is defined in the standard library as `Option`
-    enum Optional<T> {
-        SomeVal(T),
-        NoVal,
-    }
+// Generics //
+struct Foo<T> { bar: T }
+//
+// This is defined in the standard library as `Option`
+enum Optional<T> {
+    SomeVal(T),
+    NoVal,
+}
 
-    // Methods //
-    impl<T> Foo<T> {
-        // Instance methods take an explicit `self` parameter.
-        // Using `self` on its own will consume the caller, while
-        // `&self` or `&mut self` will create immutable and mutable
-        // references, respectively.
-        fn get_bar(self) -> T {
-            self.bar
-        }
-        // Static methods don't take a `self` parameter, but can still
-        // use the generic `T` type.
-        fn do_baz(msg: &str, baz: T) -> T {
-            println!("{}", msg);
-            baz
-        }
+// Methods //
+impl<T> Foo<T> {
+    // Instance methods take an explicit `self` parameter.
+    // Using `self` on its own will consume the caller, while
+    // `&self` or `&mut self` will create immutable and mutable
+    // references, respectively.
+    fn get_bar(self) -> T {
+        self.bar
+    }
+    // Static methods don't take a `self` parameter, but can still
+    // use the generic `T` type.
+    fn do_baz(msg: &str, baz: T) -> T {
+        println!("{}", msg);
+        baz
     }
-    // Here `T` is inferred to be some integer type
-    let a_foo = Foo { bar: 1 };
-    println!("{}", a_foo.get_bar()); // 1
+}
+// Here `T` is inferred to be some integer type
+let a_foo = Foo { bar: 1 };
+println!("{}", a_foo.get_bar()); // 1
 
-    // `T` can be whatever you want, using "turbofish" syntax
-    // The statement below prints "Hello" and sets `result` to 24
-    let result: i32 = Foo::<i32>::do_baz("Hello", 24);
+// `T` can be whatever you want, using "turbofish" syntax
+// The statement below prints "Hello" and sets `result` to 24
+let result: i32 = Foo::<i32>::do_baz("Hello", 24);
 
-    // Traits (known as interfaces or typeclasses in other languages) //
-    trait Frobnicate<T> {
-        fn frobnicate(self) -> Option<T>;
-    }
-    impl<T> Frobnicate<T> for Foo<T> {
-        fn frobnicate(self) -> Option<T> {
-            Some(self.bar)
-        }
+// Traits (known as interfaces or typeclasses in other languages) //
+trait Frobnicate<T> {
+    fn frobnicate(self) -> Option<T>;
+}
+impl<T> Frobnicate<T> for Foo<T> {
+    fn frobnicate(self) -> Option<T> {
+        Some(self.bar)
     }
-    let another_foo = Foo { bar: 1 };
-    println!("{:?}", another_foo.frobnicate()); // Some(1)
+}
+let another_foo = Foo { bar: 1 };
+println!("{:?}", another_foo.frobnicate()); // Some(1)