Rustfmt either_or_both

Author: Avi-D-coder

src/either_or_both.rs

@@ -26,49 +26,49 @@ impl<A, B> EitherOrBoth<A, B> {
 
     /// If Left, return true otherwise, return false.
     /// Exclusive version of [`has_left`].
-    pub fn is_just_left(&self) ->  bool {
+    pub fn is_just_left(&self) -> bool {
         match *self {
             Left(_) => true,
-            _ => false
+            _ => false,
         }
     }
 
     /// If Right, return true otherwise, return false.
     /// Exclusive version of [`has_right`].
-    pub fn is_just_right(&self) ->  bool {
+    pub fn is_just_right(&self) -> bool {
         match *self {
             Right(_) => true,
-            _ => false
+            _ => false,
         }
     }
 
     /// If Right, return true otherwise, return false.
     /// Equivalent to `self.as_ref().both().is_some()`.
-    pub fn is_just_both(&self) ->  bool {
+    pub fn is_just_both(&self) -> bool {
         self.as_ref().both().is_some()
     }
 
     /// If `Left`, or `Both`, return `Some` with the left value, otherwise, return `None`.
     pub fn left(self) -> Option<A> {
         match self {
             Left(left) | Both(left, _) => Some(left),
-            _ => None
+            _ => None,
         }
     }
 
     /// If `Right`, or `Both`, return `Some` with the right value, otherwise, return `None`.
     pub fn right(self) -> Option<B> {
         match self {
             Right(right) | Both(_, right) => Some(right),
-            _ => None
+            _ => None,
         }
     }
 
     /// If Both, return `Some` tuple containing left and right.
     pub fn both(self) -> Option<(A, B)> {
         match self {
             Both(a, b) => Some((a, b)),
-            _ => None
+            _ => None,
         }
     }
 
@@ -93,7 +93,10 @@ impl<A, B> EitherOrBoth<A, B> {
     /// Convert `EitherOrBoth<A, B>` to `EitherOrBoth<B, A>`.
     pub fn flip(self) -> EitherOrBoth<B, A> {
         match self {
-            Left(a) => Right(a), Right(b) => Left(b), Both(a, b) => Both(b, a), }
+            Left(a) => Right(a),
+            Right(b) => Left(b),
+            Both(a, b) => Both(b, a),
+        }
     }
 
     /// Apply the function `f` on the value `a` in `Left(a)` or `Both(a, b)` variants. If it is
@@ -104,7 +107,9 @@ impl<A, B> EitherOrBoth<A, B> {
     {
         match self {
             Both(a, b) => Both(f(a), b),
-            Left(a) => Left(f(a)), Right(b) => Right(b), }
+            Left(a) => Left(f(a)),
+            Right(b) => Right(b),
+        }
     }
 
     /// Apply the function `f` on the value `b` in `Right(b)` or `Both(a, b)` variants.