fmt

Author: fen-dada

algorithm/algo.mbt

@@ -1,6 +1,7 @@
 ///| Min Max
 
-///| Maximum value
+///|
+/// Maximum value
 /// 
 /// # Parameters
 /// 
@@ -23,7 +24,8 @@ pub fn[T : Compare] max(a : T, b : T) -> T {
   }
 }
 
-///| Minimum value
+///|
+/// Minimum value
 /// 
 /// # Parameters
 /// 
@@ -46,7 +48,8 @@ pub fn[T : Compare] min(a : T, b : T) -> T {
   }
 }
 
-///| Maximum value in array
+///|
+/// Maximum value in array
 /// 
 /// # Parameters
 /// 
@@ -70,7 +73,8 @@ pub fn[T : Compare] max_element(data : Array[T]) -> T {
   data.fold(init=data[0], fn(mx, x) { if x > mx { x } else { mx } })
 }
 
-///| Minimum value in array
+///|
+/// Minimum value in array
 /// 
 /// # Parameters
 /// 
@@ -96,7 +100,8 @@ pub fn[T : Compare] min_element(data : Array[T]) -> T {
 
 ///| Binary Search
 
-///| Find first index of element in array that not less than value
+///|
+/// Find first index of element in array that not less than value
 /// 
 /// # Parameters
 /// 
@@ -130,7 +135,8 @@ pub fn[T : Compare] lower_bound(data : Array[T], value : T) -> Int {
   first
 }
 
-///| Find first index of element in array that bigger than value
+///|
+/// Find first index of element in array that bigger than value
 /// 
 /// # Parameters
 /// 
@@ -163,7 +169,8 @@ pub fn[T : Compare] upper_bound(data : Array[T], value : T) -> Int {
   first
 }
 
-///| Find whether a value in the array
+///|
+/// Find whether a value in the array
 /// 
 /// # Parameters
 /// 
@@ -185,7 +192,8 @@ pub fn[T : Compare] binary_search(data : Array[T], value : T) -> Bool {
   first != data.length() && data[first] == value
 }
 
-///| Find range of array equal to value
+///|
+/// Find range of array equal to value
 /// 
 /// # Parameters
 /// 
@@ -213,7 +221,8 @@ pub fn[T : Compare] equal_range(data : Array[T], value : T) -> (Int, Int) {
 
 ///| Merge
 
-///| Merge two sorted array in sequence
+///|
+/// Merge two sorted array in sequence
 /// 
 /// # Parameters
 /// 
@@ -254,7 +263,8 @@ pub fn[T : Compare] merge(data1 : Array[T], data2 : Array[T]) -> Array[T] {
   res.iter().concat(data2[j:].iter()).collect()
 }
 
-///| Fast Exponentiation
+///|
+/// Fast Exponentiation
 /// 
 /// # Parameters
 /// 
@@ -290,7 +300,8 @@ pub(all) struct Point {
   y : Int
 } derive(Show)
 
-///| Calculate max manhattan distance
+///|
+/// Calculate max manhattan distance
 /// 
 /// # Parameters
 /// 
@@ -401,7 +412,8 @@ pub fn ext_euc(a : Int, b : Int) -> (Int, Int, Int) {
   }
 }
 
-///| Calculate Inverse Element
+///|
+/// Calculate Inverse Element
 /// 
 /// # Parameters
 /// 

algorithm/pkg.generated.mbti

@@ -0,0 +1,47 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/algorithm"
+
+// Values
+fn[T : Compare] binary_search(Array[T], T) -> Bool
+
+fn[T : Compare] equal_range(Array[T], T) -> (Int, Int)
+
+fn ext_euc(Int, Int) -> (Int, Int, Int)
+
+fn gcd(Int, Int) -> Int
+
+fn lcm(Int, Int) -> Int
+
+fn[T : Compare] lower_bound(Array[T], T) -> Int
+
+fn[T : Compare] max(T, T) -> T
+
+fn[T : Compare] max_element(Array[T]) -> T
+
+fn max_manhattan_distance(Array[Point]) -> Int
+
+fn[T : Compare] merge(Array[T], Array[T]) -> Array[T]
+
+fn[T : Compare] min(T, T) -> T
+
+fn[T : Compare] min_element(Array[T]) -> T
+
+fn mod_inverse(Int, Int) -> Int
+
+fn quick_pow(Int, Int) -> Int64
+
+fn[T : Compare] upper_bound(Array[T], T) -> Int
+
+// Errors
+
+// Types and methods
+pub(all) struct Point {
+  x : Int
+  y : Int
+}
+impl Show for Point
+
+// Type aliases
+
+// Traits
+

apsp/floyd.mbt

@@ -4,7 +4,8 @@ struct Floyd {
   node : Int
 }
 
-///| Create Floyd (All-Pairs Shortest Path)
+///|
+/// Create Floyd (All-Pairs Shortest Path)
 /// 
 /// # Parameters
 /// 
@@ -47,7 +48,8 @@ pub fn create_floyd(edge : Array[(Int, Int, Int)], node : Int) -> Floyd {
   Floyd::{ map, node }
 }
 
-///| Query shortest path
+///|
+/// Query shortest path
 /// 
 /// # Parameters
 /// 

apsp/pkg.generated.mbti

@@ -0,0 +1,16 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/apsp"
+
+// Values
+fn create_floyd(Array[(Int, Int, Int)], Int) -> Floyd
+
+// Errors
+
+// Types and methods
+type Floyd
+fn Floyd::query(Self, Int, Int) -> Int
+
+// Type aliases
+
+// Traits
+

avl/pkg.generated.mbti

@@ -0,0 +1,38 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/avl"
+
+// Values
+fn balance_factor(AVLTree) -> Int
+
+fn height(AVLTree?) -> Int
+
+fn insert(AVLTree?, Int) -> AVLTree?
+
+fn left_rotate(AVLTree) -> AVLTree
+
+fn max(Int, Int) -> Int
+
+fn new(Int) -> AVLTree
+
+fn remove(AVLTree?, Int) -> AVLTree?
+
+fn right_rotate(AVLTree) -> AVLTree
+
+fn rotate(AVLTree) -> AVLTree
+
+fn update_height(AVLTree) -> AVLTree
+
+// Errors
+
+// Types and methods
+pub(all) struct AVLTree {
+  val : Int
+  height : Int
+  left : AVLTree?
+  right : AVLTree?
+}
+
+// Type aliases
+
+// Traits
+

binary_indexed/binary_indexed_tree.mbt

@@ -18,7 +18,8 @@ fn update_in(self : Tree[Int], x : Int, val : Int) -> Unit {
   }
 }
 
-///| Update
+///|
+/// Update
 /// 
 /// # Parameters
 /// 
@@ -40,7 +41,8 @@ pub fn update(self : Tree[Int], left : Int, right : Int, val : Int) -> Unit {
   self.update_in(right + 1, -val)
 }
 
-///| Build Binary Indexed Tree
+///|
+/// Build Binary Indexed Tree
 /// 
 /// # Parameters
 /// 
@@ -64,7 +66,8 @@ pub fn query(self : Tree[Int], x : Int) -> Int {
   res
 }
 
-///| Build Binary Indexed Tree
+///|
+/// Build Binary Indexed Tree
 /// 
 /// # Parameters
 /// 

binary_indexed/pkg.generated.mbti

@@ -0,0 +1,17 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/binary_indexed"
+
+// Values
+fn bitTree(Array[Int]) -> Tree[Int]
+
+// Errors
+
+// Types and methods
+type Tree[Int]
+fn Tree::query(Self[Int], Int) -> Int
+fn Tree::update(Self[Int], Int, Int, Int) -> Unit
+
+// Type aliases
+
+// Traits
+

combinator/Combinator.mbt

@@ -22,7 +22,8 @@ fn qpow(base : Int64, exp : Int64, mod : Int64) -> Int64 {
   res
 }
 
-///| Constructor
+///|
+/// Constructor
 /// 
 /// # Parameters
 /// 
@@ -47,7 +48,8 @@ pub fn Comb::new(size : Int, mod : Int64) -> Comb {
   { fact, inv_fact, mod }
 }
 
-///| Combination
+///|
+/// Combination
 /// 
 /// # Parameters
 /// 
@@ -74,7 +76,8 @@ pub fn c(self : Comb, x : Int, y : Int) -> Int64 {
   self.fact[x] * self.inv_fact[y] % self.mod * self.inv_fact[x - y] % self.mod
 }
 
-///| Arrangement
+///|
+/// Arrangement
 /// 
 /// # Parameters
 /// 

combinator/pkg.generated.mbti

@@ -0,0 +1,17 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "Lampese/Algorithms-Moonbit/combinator"
+
+// Values
+
+// Errors
+
+// Types and methods
+type Comb
+fn Comb::a(Self, Int, Int) -> Int64
+fn Comb::c(Self, Int, Int) -> Int64
+fn Comb::new(Int, Int64) -> Self
+
+// Type aliases
+
+// Traits
+

dsu/dsu.mbt

@@ -6,7 +6,8 @@ struct DSU {
 
 ///|
 
-///| Construct a dsu structure
+///|
+/// Construct a dsu structure
 /// 
 /// # Parameters
 /// 
@@ -32,7 +33,8 @@ pub fn DSU::new(n : Int) -> DSU {
   { parent, siz }
 }
 
-///| Find the root of x
+///|
+/// Find the root of x
 /// 
 /// # Parameters
 /// 
@@ -59,7 +61,8 @@ pub fn find(self : DSU, x : Int) -> Int {
   root
 }
 
-///| Merge two unions x and y into one unoin
+///|
+/// Merge two unions x and y into one unoin
 /// 
 /// # Parameters
 /// 
@@ -94,7 +97,8 @@ pub fn merge(self : DSU, x : Int, y : Int) -> Bool {
   true
 }
 
-///| Find out that if x and y belong to the same union
+///|
+/// Find out that if x and y belong to the same union
 /// 
 /// # Parameters
 /// 
@@ -117,7 +121,8 @@ pub fn same(self : DSU, x : Int, y : Int) -> Bool {
   self.find(x) == self.find(y)
 }
 
-///| Get the size of the union that x belongs to
+///|
+/// Get the size of the union that x belongs to
 /// 
 /// # Parameters
 ///