fmt code

Author: fen-dada

algorithm/algo.mbt

@@ -367,7 +367,7 @@ pub fn gcd(a : Int, b : Int) -> Int {
 /// 
 /// ```
 pub fn lcm(a : Int, b : Int) -> Int {
-    a * b / gcd(a, b)
+  a * b / gcd(a, b)
 }
 
 ///|

prefix_sum/prefix.mbt

@@ -13,9 +13,9 @@ enum Prefix2d[T] {
 // make prefix for 1 dimension
 
 ///|
-fn[T: Add + Default] prefix1d(data : Array[T]) -> Array[T] {
+fn[T : Add + Default] prefix1d(data : Array[T]) -> Array[T] {
   let n = data.length()
-  let ret: Array[T] = Array::make(n + 1, T::default())
+  let ret : Array[T] = Array::make(n + 1, T::default())
   if n > 0 {
     ret[1] = data[0]
     for i = 1; i < n; i = i + 1 {
@@ -28,13 +28,15 @@ fn[T: Add + Default] prefix1d(data : Array[T]) -> Array[T] {
 // make prefix for 2 dimension
 
 ///|
-fn[T: Add + Sub + Default] prefix2d(data : Array[Array[T]]) -> Array[Array[T]] {
+fn[T : Add + Sub + Default] prefix2d(data : Array[Array[T]]) -> Array[Array[T]] {
   let n = data.length()
   if n == 0 {
     return []
   }
   let m = data[0].length()
-  let ret: Array[Array[T]] = Array::makei(n + 1, fn(_row : Int) { Array::make(m + 1, T::default()) })
+  let ret : Array[Array[T]] = Array::makei(n + 1, fn(_row : Int) {
+    Array::make(m + 1, T::default())
+  })
   for i = 1; i <= n; i = i + 1 {
     for j = 1; j <= m; j = j + 1 {
       ret[i][j] = ret[i][j - 1] +
@@ -64,7 +66,7 @@ fn[T: Add + Sub + Default] prefix2d(data : Array[Array[T]]) -> Array[Array[T]] {
 ///   let pre1 = Prefix1d::from(a1)
 ///   inspect(pre1.sum(2, 4), content="9")
 /// ```
-pub fn[T: Sub] Prefix1d::sum(self : Self[T], left : Int, right : Int) -> T {
+pub fn[T : Sub] Prefix1d::sum(self : Self[T], left : Int, right : Int) -> T {
   match self {
     Nil => abort("Cannot sum on an empty prefix structure")
     Pre(pre, n) => {
@@ -91,7 +93,7 @@ pub fn[T: Sub] Prefix1d::sum(self : Self[T], left : Int, right : Int) -> T {
 /// let arr = [1, 2, 3, 4]
 /// let _ = Prefix1d::from(arr)
 /// ```
-pub fn[T: Add + Default] Prefix1d::from(data : Array[T]) -> Prefix1d[T] {
+pub fn[T : Add + Default] Prefix1d::from(data : Array[T]) -> Prefix1d[T] {
   match data.length() {
     0 => Nil
     n => Pre(prefix1d(data), n)
@@ -118,7 +120,13 @@ pub fn[T: Add + Default] Prefix1d::from(data : Array[T]) -> Prefix1d[T] {
 ///   let pre2 = Prefix2d::from(a2)
 ///   inspect(pre2.sum(2,2,3,3), content="34")
 /// ```
-pub fn[T: Add + Sub] Prefix2d::sum(self : Self[T], x1 : Int, y1 : Int, x2 : Int, y2 : Int) -> T {
+pub fn[T : Add + Sub] Prefix2d::sum(
+  self : Self[T],
+  x1 : Int,
+  y1 : Int,
+  x2 : Int,
+  y2 : Int,
+) -> T {
   match self {
     Nil => abort("Cannot sum on an empty prefix structure")
     Pre(pre, n, m) => {
@@ -145,7 +153,9 @@ pub fn[T: Add + Sub] Prefix2d::sum(self : Self[T], x1 : Int, y1 : Int, x2 : Int,
 /// let arr = [[1,2,3],[5,6,7],[9,10,11]]
 /// let _ = Prefix2d::from(arr)
 /// ```
-pub fn[T: Add + Sub + Default] Prefix2d::from(data : Array[Array[T]]) -> Prefix2d[T] {
+pub fn[T : Add + Sub + Default] Prefix2d::from(
+  data : Array[Array[T]],
+) -> Prefix2d[T] {
   let n = data.length()
   if n == 0 {
     return Nil

prefix_sum/prefix_test.mbt

@@ -6,7 +6,7 @@ test {
   let a2 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
   let pre2 = Prefix2d::from(a2)
   inspect(pre2.sum(2, 2, 3, 3), content="34")
-  let a3 = [1.1,2.2,3.3,4.4]
+  let a3 = [1.1, 2.2, 3.3, 4.4]
   let pre3 = Prefix1d::from(a3)
   inspect(pre3.sum(1, 3), content="6.6")
 }

st/st.mbt

@@ -2,7 +2,7 @@
 struct ST[T] {
   n : Int
   f : Array[Array[T]]
-  op: (T, T) -> T
+  op : (T, T) -> T
 }
 
 ///| Build Sparse Table
@@ -20,10 +20,12 @@ struct ST[T] {
 /// let arr = [1,2,3,4,5,6,1,2]
 /// let _ = from(arr, @cmp.maximum)
 /// ```
-pub fn[T: Default] from(data : Array[T], op: (T, T) -> T) -> ST[T] {
+pub fn[T : Default] from(data : Array[T], op : (T, T) -> T) -> ST[T] {
   let n = data.length()
   let range : Int = @math.log2(n.to_double()).to_int() + 1
-  let f: Array[Array[T]] = Array::makei(n+1, fn(_row: Int) {Array::make(range, T::default())} )
+  let f : Array[Array[T]] = Array::makei(n + 1, fn(_row : Int) {
+    Array::make(range, T::default())
+  })
   for i = 0; i < n; i = i + 1 {
     f[i + 1][0] = data[i]
   }
@@ -32,7 +34,7 @@ pub fn[T: Default] from(data : Array[T], op: (T, T) -> T) -> ST[T] {
       f[i][j] = op(f[i][j - 1], f[i + (1 << (j - 1))][j - 1])
     }
   }
-  ST::{ n, f, op}
+  ST::{ n, f, op }
 }
 
 ///| Build Binary Indexed Tree
@@ -52,7 +54,7 @@ pub fn[T: Default] from(data : Array[T], op: (T, T) -> T) -> ST[T] {
 ///   inspect(st.query(1, 1), content="1")
 ///   inspect(st.query(2, 8), content="6")
 /// ```
-pub fn[T] query(self : ST[T], left : Int, right : Int) -> T{
+pub fn[T] query(self : ST[T], left : Int, right : Int) -> T {
   if right < left {
     abort("Invalid range.")
   } else if left > self.n || right < 1 {

st/st_test.mbt

@@ -5,22 +5,25 @@ test "max query" {
   inspect(st.query(1, 1), content="1")
   inspect(st.query(2, 8), content="6")
 }
+
 ///|
 test "min query" {
   let arr = [1, 2, 3, 4, 5, 6, 1, 2]
   let st = from(arr, @cmp.minimum)
   inspect(st.query(1, 1), content="1")
   inspect(st.query(2, 8), content="1")
 }
+
 ///|
 test "gcd query" {
-  fn gcd(a: Int, b: Int) -> Int {
-      if b==0 {
-          a
-      } else {
-        gcd(b, a%b)
-      }
+  fn gcd(a : Int, b : Int) -> Int {
+    if b == 0 {
+      a
+    } else {
+      gcd(b, a % b)
     }
+  }
+
   let arr = [4, 8, 16, 24, 48, 3]
   let st = from(arr, gcd)
   inspect(st.query(1, 2), content="4")