refactor(tree, rustfmt): move private function below and set max_width to 119

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 119

src/collection.rs

@@ -28,11 +28,7 @@ impl<T: Copy> Iterator for Bitset<T> {
 
 pub fn bitset<T: Copy>(a: Vec<T>) -> Bitset<T> {
     let len = a.len();
-    Bitset {
-        curr: 0,
-        array: a,
-        len,
-    }
+    Bitset { curr: 0, array: a, len }
 }
 
 #[cfg(test)]

src/geometry.rs

@@ -179,11 +179,7 @@ pub fn convex_hull(ps: Vec<(i64, i64)>) -> Vec<(i64, i64)> {
         k += 1;
     }
 
-    let mut ret: Vec<(i64, i64)> = deque
-        .into_iter()
-        .take(k - 1)
-        .map(|pair| (pair.0, pair.1))
-        .collect();
+    let mut ret: Vec<(i64, i64)> = deque.into_iter().take(k - 1).map(|pair| (pair.0, pair.1)).collect();
 
     ret.sort_unstable();
     ret

src/graph.rs

@@ -51,10 +51,7 @@ impl Graph {
     }
 
     pub fn connect_with_residual(&mut self, from: usize, to: usize, weight: usize) {
-        assert!(
-            self.directed,
-            "connect_with_residual only works in directed graph."
-        );
+        assert!(self.directed, "connect_with_residual only works in directed graph.");
 
         self.graph[from].push((to, weight));
         self.out_degrees[from] += 1;
@@ -93,14 +90,7 @@ mod test_graph {
         graph.connect(1, 0, 10);
         graph.connect(3, 4, 3);
 
-        let expected = vec![
-            vec![(1, 1)],
-            vec![(0, 10)],
-            vec![(5, 1)],
-            vec![(4, 3)],
-            vec![],
-            vec![],
-        ];
+        let expected = vec![vec![(1, 1)], vec![(0, 10)], vec![(5, 1)], vec![(4, 3)], vec![], vec![]];
         assert_eq!(graph.graph, expected);
 
         assert!(graph.connected(0, 1));
@@ -260,7 +250,7 @@ impl DepthFirstSearch {
 
         while let Some(node_type) = stack.pop_front() {
             match node_type {
-                NodeType::Forward(u)  => {
+                NodeType::Forward(u) => {
                     for &(v, _) in self.graph.graph[u].iter() {
                         if self.seen[v] {
                             continue;
@@ -408,10 +398,7 @@ mod test_dijkstra {
 
         let mut dijkstra = Dijkstra::new(graph);
         dijkstra.search(0);
-        assert_eq!(
-            dijkstra.dist,
-            vec![0, 1, 6, 3, 5, 8, 10, Dijkstra::INF, Dijkstra::INF]
-        );
+        assert_eq!(dijkstra.dist, vec![0, 1, 6, 3, 5, 8, 10, Dijkstra::INF, Dijkstra::INF]);
 
         assert_eq!(dijkstra.shortest_path(0, 3), vec![(0, 1), (1, 3)]);
         assert_eq!(dijkstra.shortest_path(0, 8), vec![]);
@@ -574,11 +561,7 @@ impl LowestCommonAncestor {
         let n = graph.n;
         let parents = vec![vec![Self::ROOT; n]; Self::LOGV];
         let depth = vec![Self::ROOT; n];
-        Self {
-            parents,
-            depth,
-            graph,
-        }
+        Self { parents, depth, graph }
     }
 
     pub fn init(&mut self) {

src/math.rs

@@ -249,9 +249,7 @@ impl SequentialPrimeFactorization {
             i += 1;
         }
 
-        Self {
-            smallest_prime_factors,
-        }
+        Self { smallest_prime_factors }
     }
 
     pub fn factorize(&self, mut x: usize) -> Vec<usize> {

src/search.rs

@@ -15,7 +15,7 @@ pub fn lower_bound(range: std::ops::Range<usize>, prop: &dyn Fn(usize) -> bool)
     }
 
     match ok.eq(&range.end) {
-        true  => None,
+        true => None,
         false => Some(ok),
     }
 }

src/tree.rs

@@ -68,32 +68,6 @@ impl SegmentTree {
         ret
     }
 
-    fn range_query_recursive(
-        &self,
-        op: &Op,
-        ql: usize,
-        qr: usize,
-        sl: usize,
-        sr: usize,
-        pos: usize,
-    ) -> i64 {
-        if qr <= sl || sr <= ql {
-            return SegmentTree::default(op);
-        }
-        if ql <= sl && sr <= qr {
-            return self.data[pos];
-        }
-
-        let sm = (sl + sr) / 2;
-        let lv = self.range_query_recursive(op, ql, qr, sl, sm, pos * 2);
-        let rv = self.range_query_recursive(op, ql, qr, sm, sr, pos * 2 + 1);
-        match op {
-            Op::Add => lv + rv,
-            Op::Max => lv.max(rv),
-            Op::Min => lv.min(rv),
-        }
-    }
-
     pub fn get_range(&self, l: usize, r: usize) -> i64 {
         if let Mode::RangeGet(op) = &self.mode {
             self.range_query_recursive(op, l, r, 0, SegmentTree::SEQ_LEN, 1)
@@ -154,6 +128,24 @@ impl SegmentTree {
             panic!("Mode {:?} is not supported.", &self.mode);
         }
     }
+
+    fn range_query_recursive(&self, op: &Op, ql: usize, qr: usize, sl: usize, sr: usize, pos: usize) -> i64 {
+        if qr <= sl || sr <= ql {
+            return SegmentTree::default(op);
+        }
+        if ql <= sl && sr <= qr {
+            return self.data[pos];
+        }
+
+        let sm = (sl + sr) / 2;
+        let lv = self.range_query_recursive(op, ql, qr, sl, sm, pos * 2);
+        let rv = self.range_query_recursive(op, ql, qr, sm, sr, pos * 2 + 1);
+        match op {
+            Op::Add => lv + rv,
+            Op::Max => lv.max(rv),
+            Op::Min => lv.min(rv),
+        }
+    }
 }
 
 #[cfg(test)]