meta: Clear code formatting with rustfmt

Kerollmops · Jan 11, 2017 · 1564094 · 1564094
1 parent 66023fd
commit 1564094
Show file tree

Hide file tree

Showing 5 changed files with 42 additions and 34 deletions.
diff --git a/src/convert_ref.rs b/src/convert_ref.rs
@@ -23,7 +23,9 @@ pub trait TryIntoRef<T>: Sized {
     fn try_into_ref(&self) -> Result<T, Self::Err>;
 }
 
-impl<T, U> TryIntoRef<U> for T where U: TryFromRef<T> {
+impl<T, U> TryIntoRef<U> for T
+    where U: TryFromRef<T>
+{
     type Err = U::Err;
 
     fn try_into_ref(&self) -> Result<U, U::Err> {

diff --git a/src/evaluate/float.rs b/src/evaluate/float.rs
@@ -40,7 +40,7 @@ pub enum FloatEvaluator<T: Float> {
     /// `"round"` will pop `1` operand and push `1`.
     Round,
     #[doc(hidden)]
-    _Phantom(PhantomData<T>)
+    _Phantom(PhantomData<T>),
 }
 
 /// Type returned when an error occurs on float operation.
@@ -58,17 +58,16 @@ impl<T: Float> Evaluate<T> for FloatEvaluator<T> {
             Add | Sub | Mul | Div | Pow | Rem | Swap => 2,
             Neg | Sqrt | Log2 | Round | Exp => 1,
             Zero | One => 0,
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         }
     }
 
     fn operands_generated(&self) -> usize {
         use self::FloatEvaluator::*;
         match *self {
-            Add | Sub | Mul | Div | Rem | Neg | Sqrt | Pow | Log2 |
-            Exp | Zero | One | Round => 1,
+            Add | Sub | Mul | Div | Rem | Neg | Sqrt | Pow | Log2 | Exp | Zero | One | Round => 1,
             Swap => 2,
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         }
     }
 
@@ -126,8 +125,8 @@ impl<T: Float> Evaluate<T> for FloatEvaluator<T> {
             Round => {
                 let a = stack.pop().unwrap();
                 Ok(stack.push(a.round()))
-            },
-            _Phantom(_) => unreachable!()
+            }
+            _Phantom(_) => unreachable!(),
         }
     }
 }
@@ -180,7 +179,7 @@ impl<T: Float> fmt::Display for FloatEvaluator<T> {
             Zero => "zero",
             One => "one",
             Round => "round",
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         };
         f.write_str(name)
     }
@@ -198,7 +197,7 @@ mod tests {
         let tokens = expr.split_whitespace();
         let res = FloatExpr::<f32>::from_iter(tokens);
         match res {
-            Err(ExprResult::InvalidToken { evaluator: FloatErr::InvalidExpr("&"), .. } ) => (),
+            Err(ExprResult::InvalidToken { evaluator: FloatErr::InvalidExpr("&"), .. }) => (),
             _ => panic!(res),
         }
     }

diff --git a/src/evaluate/integer.rs b/src/evaluate/integer.rs
@@ -33,7 +33,7 @@ pub enum IntEvaluator<T: PrimInt + Signed> {
     /// `"zero"` will pop `0` operand and push `1`.
     One,
     #[doc(hidden)]
-    _Phantom(PhantomData<T>)
+    _Phantom(PhantomData<T>),
 }
 
 /// Type returned when an error occurs on signed integer operation.
@@ -57,7 +57,7 @@ impl<T: PrimInt + Signed> Evaluate<T> for IntEvaluator<T> {
             Add | Sub | Mul | Div | Pow | Rem | Swap => 2,
             Neg => 1,
             Zero | One => 0,
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         }
     }
 
@@ -66,7 +66,7 @@ impl<T: PrimInt + Signed> Evaluate<T> for IntEvaluator<T> {
         match *self {
             Add | Sub | Mul | Div | Rem | Neg | Pow | Zero | One => 1,
             Swap => 2,
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         }
     }
 
@@ -98,8 +98,7 @@ impl<T: PrimInt + Signed> Evaluate<T> for IntEvaluator<T> {
                 let (a, b) = pop_two_operands(stack).unwrap();
                 if b == T::zero() {
                     Err(InvalidRem(a, b))
-                }
-                else {
+                } else {
                     Ok(stack.push(a % b))
                 }
             }
@@ -121,7 +120,7 @@ impl<T: PrimInt + Signed> Evaluate<T> for IntEvaluator<T> {
             }
             Zero => Ok(stack.push(T::zero())),
             One => Ok(stack.push(T::one())),
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         }
     }
 }
@@ -166,7 +165,7 @@ impl<T: PrimInt + Signed> fmt::Display for IntEvaluator<T> {
             Swap => "swap",
             Zero => "zero",
             One => "one",
-            _Phantom(_) => unreachable!()
+            _Phantom(_) => unreachable!(),
         };
         f.write_str(name)
     }

diff --git a/src/expression.rs b/src/expression.rs
@@ -78,10 +78,11 @@ impl<T: Copy, V: Copy, E: Evaluate<T> + Copy> Expression<T, V, E> {
 }
 
 impl<T, V, E: Evaluate<T>> Expression<T, V, E> {
-    pub fn from_iter<A, I>(iter: I) -> Result<Expression<T, V, E>,
-                                              ExprResult<<E as TryFromRef<A>>::Err,
-                                                         <V as TryFromRef<A>>::Err,
-                                                         <T as TryFromRef<A>>::Err>>
+    pub fn from_iter<A, I>(iter: I)
+                           -> Result<Expression<T, V, E>,
+                                     ExprResult<<E as TryFromRef<A>>::Err,
+                                                <V as TryFromRef<A>>::Err,
+                                                <T as TryFromRef<A>>::Err>>
         where T: TryFromRef<A>,
               V: TryFromRef<A>,
               E: TryFromRef<A>,
@@ -101,17 +102,17 @@ impl<T, V, E: Evaluate<T>> Expression<T, V, E> {
                                     variable: var_err,
                                     operand: op_err,
                                 })
-                            }
-                        }
-                    }
-                }
+                             }
+                         }
+                     }
+                 }
             }
         }).collect();
         final_expr.and_then(|final_expr| {
             match Expression::check_validity(&final_expr) {
                 Ok(_) => Ok(Expression {
                     max_stack: Expression::compute_stack_max(&final_expr),
-                    expr: final_expr
+                    expr: final_expr,
                 }),
                 Err(err) => Err(ExprResult::OperandErr(err)),
             }
@@ -126,7 +127,7 @@ pub enum ExprResult<A, B, C> {
     InvalidToken {
         evaluator: A,
         variable: B,
-        operand: C
+        operand: C,
     },
 }
 
@@ -144,12 +145,13 @@ impl<T, V, E: Evaluate<T>> Expression<T, V, E> {
         let mut num_operands: usize = 0;
         for arithm in expr {
             match *arithm {
-                Arithm::Operand(_) | Arithm::Variable(_) => num_operands += 1,
+                Arithm::Operand(_) |
+                Arithm::Variable(_) => num_operands += 1,
                 Arithm::Evaluator(ref evaluator) => {
                     let needed = evaluator.operands_needed();
                     num_operands = num_operands.checked_sub(needed).ok_or(NotEnoughOperand)?;
                     num_operands += evaluator.operands_generated();
-                },
+                }
             }
         }
         match num_operands {
@@ -162,16 +164,22 @@ impl<T, V, E: Evaluate<T>> Expression<T, V, E> {
 
 impl<T, V, E: Evaluate<T>> Expression<T, V, E> {
     fn compute_stack_max(expr: &[Arithm<T, V, E>]) -> usize {
-        expr.iter().map(|arithm| {
+        expr.iter() .map(|arithm| {
             match *arithm {
-                Arithm::Operand(_) | Arithm::Variable(_) => 1,
+                Arithm::Operand(_) |
+                Arithm::Variable(_) => 1,
                 Arithm::Evaluator(ref op) => {
                     op.operands_generated() as isize - op.operands_needed() as isize
                 }
             }
-        }).fold((0, 0isize), |(max, acc_count), count| {
+        })
+        .fold((0, 0isize), |(max, acc_count), count| {
             let acc = (acc_count + count) as usize;
-            if acc > max { (acc, acc as isize) } else { (max, acc as isize) }
+            if acc > max {
+                (acc, acc as isize)
+            } else {
+                (max, acc as isize)
+            }
         }).0
     }
 }

diff --git a/src/variable/index_var.rs b/src/variable/index_var.rs
@@ -27,7 +27,7 @@ impl<'a> TryFromRef<&'a str> for IndexVar {
                     Ok(n) => Ok(IndexVar(n)),
                     Err(err) => Err(VarIdxErr::ConvertErr(err)),
                 }
-            },
+            }
             _ => Err(VarIdxErr::InvalidVariableName(s)),
         }
     }