Have rustfmt group imports (#60)

* Have rustfmt group imports

See `rustfmt.toml`; the rest is automated changes.

* fmt

rustfmt.toml

@@ -0,0 +1,2 @@
+unstable_features = true
+group_imports = "StdExternalCrate"

src/bin/bench_ldes.rs

@@ -1,10 +1,9 @@
 use std::time::Instant;
 
-use rayon::prelude::*;
-
 use plonky2::field::crandall_field::CrandallField;
 use plonky2::field::field::Field;
 use plonky2::polynomial::polynomial::PolynomialValues;
+use rayon::prelude::*;
 
 type F = CrandallField;
 

src/bin/bench_recursion.rs

@@ -1,5 +1,4 @@
 use env_logger::Env;
-
 use plonky2::circuit_builder::CircuitBuilder;
 use plonky2::circuit_data::CircuitConfig;
 use plonky2::field::crandall_field::CrandallField;

src/field/crandall_field.rs

@@ -1,5 +1,7 @@
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
+use std::hash::{Hash, Hasher};
+use std::iter::{Product, Sum};
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 use num::Integer;
@@ -8,8 +10,6 @@ use crate::field::extension_field::quadratic::QuadraticCrandallField;
 use crate::field::extension_field::quartic::QuarticCrandallField;
 use crate::field::extension_field::Extendable;
 use crate::field::field::Field;
-use std::hash::{Hash, Hasher};
-use std::iter::{Product, Sum};
 
 /// EPSILON = 9 * 2**28 - 1
 const EPSILON: u64 = 2415919103;

src/field/extension_field/algebra.rs

@@ -1,8 +1,9 @@
-use crate::field::extension_field::OEF;
 use std::fmt::{Debug, Display, Formatter};
 use std::iter::{Product, Sum};
 use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
+use crate::field::extension_field::OEF;
+
 /// Let `F_D` be the optimal extension field `F[X]/(X^D-W)`. Then `ExtensionAlgebra<F_D>` is the quotient `F_D[X]/(X^D-W)`.
 /// It's a `D`-dimensional algebra over `F_D` useful to lift the multiplication over `F_D` to a multiplication over `(F_D)^D`.
 #[derive(Copy, Clone)]
@@ -154,11 +155,12 @@ impl<F: OEF<D>, const D: usize> PolynomialCoeffsAlgebra<F, D> {
 
 #[cfg(test)]
 mod tests {
+    use itertools::Itertools;
+
     use crate::field::crandall_field::CrandallField;
     use crate::field::extension_field::algebra::ExtensionAlgebra;
     use crate::field::extension_field::{Extendable, FieldExtension};
     use crate::field::field::Field;
-    use itertools::Itertools;
 
     /// Tests that the multiplication on the extension algebra lifts that of the field extension.
     fn test_extension_algebra<F: Extendable<D>, const D: usize>() {

src/field/extension_field/quadratic.rs

@@ -1,12 +1,14 @@
-use crate::field::crandall_field::CrandallField;
-use crate::field::extension_field::{FieldExtension, OEF};
-use crate::field::field::Field;
-use rand::Rng;
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::Hash;
 use std::iter::{Product, Sum};
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
+use rand::Rng;
+
+use crate::field::crandall_field::CrandallField;
+use crate::field::extension_field::{FieldExtension, OEF};
+use crate::field::field::Field;
+
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct QuadraticCrandallField([CrandallField; 2]);
 

src/field/field_testing.rs

@@ -142,9 +142,10 @@ pub fn run_binaryop_test_cases<F, BinaryOp, ExpectedOp>(
 macro_rules! test_arithmetic {
     ($field:ty) => {
         mod arithmetic {
-            use crate::field::field::Field;
             use std::ops::{Add, Mul, Neg, Sub};
 
+            use crate::field::field::Field;
+
             // Can be 32 or 64; doesn't have to be computer's actual word
             // bits. Choosing 32 gives more tests...
             const WORD_BITS: usize = 32;

src/merkle_tree.rs

@@ -84,11 +84,10 @@ impl<F: Field> MerkleTree<F> {
 mod tests {
     use anyhow::Result;
 
+    use super::*;
     use crate::field::crandall_field::CrandallField;
     use crate::merkle_proofs::verify_merkle_proof;
 
-    use super::*;
-
     fn random_data<F: Field>(n: usize, k: usize) -> Vec<Vec<F>> {
         (0..n).map(|_| F::rand_vec(k)).collect()
     }

src/polynomial/commitment.rs

@@ -340,9 +340,8 @@ mod tests {
     }
 
     mod quadratic {
-        use crate::field::crandall_field::CrandallField;
-
         use super::*;
+        use crate::field::crandall_field::CrandallField;
 
         #[test]
         fn test_batch_polynomial_commitment() -> Result<()> {
@@ -351,9 +350,8 @@ mod tests {
     }
 
     mod quartic {
-        use crate::field::crandall_field::CrandallField;
-
         use super::*;
+        use crate::field::crandall_field::CrandallField;
 
         #[test]
         fn test_batch_polynomial_commitment() -> Result<()> {

src/polynomial/polynomial.rs

@@ -1,11 +1,11 @@
 use std::cmp::max;
+use std::iter::Sum;
 use std::ops::{Add, Mul, Sub};
 
 use crate::field::extension_field::Extendable;
 use crate::field::fft::{fft, ifft};
 use crate::field::field::Field;
 use crate::util::log2_strict;
-use std::iter::Sum;
 
 /// A polynomial in point-value form.
 ///
@@ -279,9 +279,8 @@ mod tests {
 
     use rand::{thread_rng, Rng};
 
-    use crate::field::crandall_field::CrandallField;
-
     use super::*;
+    use crate::field::crandall_field::CrandallField;
 
     #[test]
     fn test_trimmed() {

src/proof.rs

@@ -1,3 +1,5 @@
+use std::convert::TryInto;
+
 use crate::field::extension_field::Extendable;
 use crate::field::field::Field;
 use crate::fri::FriConfig;
@@ -5,7 +7,6 @@ use crate::merkle_proofs::{MerkleProof, MerkleProofTarget};
 use crate::polynomial::commitment::{ListPolynomialCommitment, OpeningProof};
 use crate::polynomial::polynomial::PolynomialCoeffs;
 use crate::target::Target;
-use std::convert::TryInto;
 
 /// Represents a ~256 bit hash output.
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]