diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 822f13a..f53ac95 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -26,7 +26,17 @@ jobs:
         run: |
           moon version --all
           moon update
-          moon install
+          moon check --deny-warn
+      
+      - name: moon info
+        run: |
+          moon info --target all
+          git diff --exit-code
+
+      - name: format diff
+        run: |
+          moon fmt
+          git diff --exit-code
 
       - name: Run tests with coverage
         run: |
diff --git a/.gitignore b/.gitignore
index ec52756..965e36e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 target/
 .mooncakes/
 .DS_Store
+_build/
diff --git a/src/snapshot_array/moon.pkg b/src/snapshot_array/moon.pkg
new file mode 100644
index 0000000..e3785e1
--- /dev/null
+++ b/src/snapshot_array/moon.pkg
@@ -0,0 +1,7 @@
+import {
+  "BigOrangeQWQ/unification_table/undo_logs" @logs,
+}
+
+options(
+  name: "BigOrangeQWQ/unification_table/snapshot_array",
+)
diff --git a/src/snapshot_array/moon.pkg.json b/src/snapshot_array/moon.pkg.json
deleted file mode 100644
index 6627c3f..0000000
--- a/src/snapshot_array/moon.pkg.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "name": "BigOrangeQWQ/unification_table/snapshot_array",
-    "import": [
-      { "path": "BigOrangeQWQ/unification_table/undo_logs", "alias": "logs"}
-    ]
-}
\ No newline at end of file
diff --git a/src/snapshot_array/pkg.generated.mbti b/src/snapshot_array/pkg.generated.mbti
new file mode 100644
index 0000000..0bb1da7
--- /dev/null
+++ b/src/snapshot_array/pkg.generated.mbti
@@ -0,0 +1,46 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "BigOrangeQWQ/unification_table/snapshot_array"
+
+import {
+  "BigOrangeQWQ/unification_table/undo_logs",
+}
+
+// Values
+pub fn[T] from_iter(Iter[T], capacity? : Int) -> SnapshotArray[T]
+
+pub fn[T] new(capacity? : Int) -> SnapshotArray[T]
+
+pub fn[T] of(FixedArray[T]) -> SnapshotArray[T]
+
+// Errors
+
+// Types and methods
+pub struct Snapshot {
+  undo_count : Int
+}
+
+pub struct SnapshotArray[T] {
+  logs : @undo_logs.UndoLogs[T]
+  values : Array[T]
+}
+pub fn[T] SnapshotArray::action_since_snapshot(Self[T], Snapshot) -> ArrayView[@undo_logs.Undo[T]]
+pub fn[T] SnapshotArray::commit(Self[T], Snapshot) -> Unit
+pub fn[T] SnapshotArray::commit_all(Self[T]) -> Unit
+pub fn[T] SnapshotArray::extend(Self[T], Iter[T]) -> Unit
+pub fn[T] SnapshotArray::get(Self[T], Int) -> T?
+pub fn[T] SnapshotArray::in_snapshot(Self[T]) -> Bool
+pub fn[T] SnapshotArray::length(Self[T]) -> Int
+pub fn[T] SnapshotArray::op_get(Self[T], Int) -> T
+pub fn[T] SnapshotArray::op_set(Self[T], Int, T) -> Unit
+pub fn[T] SnapshotArray::push(Self[T], T) -> Unit
+pub fn[T] SnapshotArray::record(Self[T], @undo_logs.Undo[T]) -> Bool
+pub fn[T] SnapshotArray::reset(Self[T]) -> Unit
+pub fn[T] SnapshotArray::rollback_to(Self[T], Snapshot) -> Unit
+pub fn[T] SnapshotArray::set(Self[T], Int, T) -> Unit
+pub fn[T] SnapshotArray::set_all(Self[T], (T) -> T) -> Unit
+pub fn[T] SnapshotArray::start_snapshot(Self[T]) -> Snapshot
+
+// Type aliases
+
+// Traits
+
diff --git a/src/snapshot_array/snapshot_array.mbt b/src/snapshot_array/snapshot_array.mbt
index 02bcd89..655588d 100644
--- a/src/snapshot_array/snapshot_array.mbt
+++ b/src/snapshot_array/snapshot_array.mbt
@@ -13,7 +13,7 @@ pub struct Snapshot {
 /// Creates a new `SnapshotArray` with an optional initial capacity.
 /// 
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr : SnapshotArray[Int] = new(capacity=5)
 /// assert_true(arr.length() == 0)
 /// ```
@@ -39,13 +39,13 @@ pub fn[T] of(values : FixedArray[T]) -> SnapshotArray[T] {
 /// Returns the number of elements in the `SnapshotArray`.
 /// 
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new(capacity=5)
 /// assert_eq(arr.length(), 0)
 /// arr.push(1)
 /// assert_eq(arr.length(), 1)
 /// ```
-pub fn[T] length(self : SnapshotArray[T]) -> Int {
+pub fn[T] SnapshotArray::length(self : SnapshotArray[T]) -> Int {
   self.values.length()
 }
 
@@ -53,14 +53,14 @@ pub fn[T] length(self : SnapshotArray[T]) -> Int {
 /// Returns the value at the specified index
 /// 
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new(capacity=5)
 /// arr.push(1)
 /// arr.push(2)
 /// assert_eq(arr.get(0).unwrap(), 1)
 /// assert_eq(arr.get(1).unwrap(), 2)
 /// ```
-pub fn[T] get(self : SnapshotArray[T], index : Int) -> T? {
+pub fn[T] SnapshotArray::get(self : SnapshotArray[T], index : Int) -> T? {
   self.values.get(index)
 }
 
@@ -68,7 +68,7 @@ pub fn[T] get(self : SnapshotArray[T], index : Int) -> T? {
 /// Revert the last action.
 ///
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// let snapshot = arr.start_snapshot()
 /// arr.push(1)
@@ -76,7 +76,7 @@ pub fn[T] get(self : SnapshotArray[T], index : Int) -> T? {
 /// arr.rollback_to(snapshot)
 /// inspect(arr.length(), content="0")
 /// ```
-fn[T] rollback(self : SnapshotArray[T]) -> Unit {
+fn[T] SnapshotArray::rollback(self : SnapshotArray[T]) -> Unit {
   let undo = self.logs.pop().unwrap()
   match undo {
     NewElem(idx) => {
@@ -95,13 +95,13 @@ fn[T] rollback(self : SnapshotArray[T]) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr : SnapshotArray[Int] = new()
 /// inspect(arr.in_snapshot(), content="false")
 /// let _ = arr.start_snapshot()
 /// inspect(arr.in_snapshot(), content="true")
 /// ```
-pub fn[T] in_snapshot(self : SnapshotArray[T]) -> Bool {
+pub fn[T] SnapshotArray::in_snapshot(self : SnapshotArray[T]) -> Bool {
   self.logs.in_snapshot()
 }
 
@@ -111,7 +111,7 @@ pub fn[T] in_snapshot(self : SnapshotArray[T]) -> Bool {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// let snapshot = arr.start_snapshot()
 /// arr.push(1)
@@ -120,7 +120,7 @@ pub fn[T] in_snapshot(self : SnapshotArray[T]) -> Bool {
 /// arr.rollback_to(snapshot)
 /// inspect(arr.length(), content="0")
 /// ```
-pub fn[T] push(self : SnapshotArray[T], elem : T) -> Unit {
+pub fn[T] SnapshotArray::push(self : SnapshotArray[T], elem : T) -> Unit {
   let len = self.values.length()
   self.values.push(elem)
   if self.in_snapshot() {
@@ -135,7 +135,7 @@ pub fn[T] push(self : SnapshotArray[T], elem : T) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr : SnapshotArray[Int] = new()
 /// arr.push(1)
 /// arr.push(2)
@@ -143,7 +143,7 @@ pub fn[T] push(self : SnapshotArray[T], elem : T) -> Unit {
 /// arr.reset()
 /// inspect(arr.length(), content="0")
 /// ```
-pub fn[T] reset(self : SnapshotArray[T]) -> Unit {
+pub fn[T] SnapshotArray::reset(self : SnapshotArray[T]) -> Unit {
   self.values.clear()
   self.logs.clear()
 }
@@ -153,13 +153,16 @@ pub fn[T] reset(self : SnapshotArray[T]) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// arr.extend([1, 2, 3].iter())
 /// inspect(arr.length(), content="3")
 /// inspect(arr.get(0).unwrap(), content="1")
 /// ```
-pub fn[T] extend(self : SnapshotArray[T], iter : Iter[T]) -> Unit {
+pub fn[T] SnapshotArray::extend(
+  self : SnapshotArray[T],
+  iter : Iter[T],
+) -> Unit {
   iter.each(fn(elem) { self.push(elem) })
 }
 
@@ -171,7 +174,7 @@ pub fn[T] extend(self : SnapshotArray[T], iter : Iter[T]) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// arr.push(1)
 /// let snapshot = arr.start_snapshot()
@@ -180,7 +183,11 @@ pub fn[T] extend(self : SnapshotArray[T], iter : Iter[T]) -> Unit {
 /// arr.rollback_to(snapshot)
 /// inspect(arr.get(0).unwrap(), content="1")
 /// ```
-pub fn[T] set(self : SnapshotArray[T], index : Int, value : T) -> Unit {
+pub fn[T] SnapshotArray::set(
+  self : SnapshotArray[T],
+  index : Int,
+  value : T,
+) -> Unit {
   if index >= self.values.length() {
     abort("Index out of bounds")
   }
@@ -197,7 +204,7 @@ pub fn[T] set(self : SnapshotArray[T], index : Int, value : T) -> Unit {
 /// rollback.
 ///
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// arr.extend([1, 2, 3].iter())
 /// let snapshot = arr.start_snapshot()
@@ -206,7 +213,10 @@ pub fn[T] set(self : SnapshotArray[T], index : Int, value : T) -> Unit {
 /// arr.rollback_to(snapshot)
 /// inspect(arr.get(0).unwrap(), content="1")
 /// ```
-pub fn[T] set_all(self : SnapshotArray[T], func : (T) -> T) -> Unit {
+pub fn[T] SnapshotArray::set_all(
+  self : SnapshotArray[T],
+  func : (T) -> T,
+) -> Unit {
   if self.in_snapshot() {
     for i in 0..<self.values.length() {
       let new_value = func(self.values[i])
@@ -228,7 +238,7 @@ pub fn[T] set_all(self : SnapshotArray[T], func : (T) -> T) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// arr.push(1)
 /// let snapshot = arr.start_snapshot()
@@ -236,7 +246,7 @@ pub fn[T] set_all(self : SnapshotArray[T], func : (T) -> T) -> Unit {
 /// arr.rollback_to(snapshot)
 /// inspect(arr.length(), content="1")
 /// ```
-pub fn[T] start_snapshot(self : SnapshotArray[T]) -> Snapshot {
+pub fn[T] SnapshotArray::start_snapshot(self : SnapshotArray[T]) -> Snapshot {
   { undo_count: self.logs.start_snapshot() }
 }
 
@@ -246,14 +256,14 @@ pub fn[T] start_snapshot(self : SnapshotArray[T]) -> Snapshot {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// let snapshot = arr.start_snapshot()
 /// arr.push(1)
 /// arr.push(2)
 /// inspect(arr.action_since_snapshot(snapshot).length(), content="2")
 /// ```
-pub fn[T] action_since_snapshot(
+pub fn[T] SnapshotArray::action_since_snapshot(
   self : SnapshotArray[T],
   snapshot : Snapshot,
 ) -> ArrayView[@logs.Undo[T]] {
@@ -268,7 +278,7 @@ pub fn[T] action_since_snapshot(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// arr.push(1)
 /// let snapshot = arr.start_snapshot()
@@ -278,7 +288,10 @@ pub fn[T] action_since_snapshot(
 /// inspect(arr.length(), content="1")
 /// inspect(arr.get(0).unwrap(), content="1")
 /// ```
-pub fn[T] rollback_to(self : SnapshotArray[T], snapshot : Snapshot) -> Unit {
+pub fn[T] SnapshotArray::rollback_to(
+  self : SnapshotArray[T],
+  snapshot : Snapshot,
+) -> Unit {
   let actions = self.action_since_snapshot(snapshot)
   let count = actions.length()
   for _ in 0..<count {
@@ -298,13 +311,16 @@ pub fn[T] rollback_to(self : SnapshotArray[T], snapshot : Snapshot) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr : SnapshotArray[Int] = new()
 /// let snapshot = arr.start_snapshot()
 /// let _ = arr.record(@logs.newElem(0))
 /// inspect(arr.action_since_snapshot(snapshot).length(), content="1")
 /// ```
-pub fn[T] record(self : SnapshotArray[T], undo : @logs.Undo[T]) -> Bool {
+pub fn[T] SnapshotArray::record(
+  self : SnapshotArray[T],
+  undo : @logs.Undo[T],
+) -> Bool {
   if self.in_snapshot() {
     self.logs.push(undo)
     return true
@@ -328,7 +344,7 @@ pub fn[T] record(self : SnapshotArray[T], undo : @logs.Undo[T]) -> Bool {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// let snapshot1 = arr.start_snapshot()
 /// arr.push(1)
@@ -340,7 +356,10 @@ pub fn[T] record(self : SnapshotArray[T], undo : @logs.Undo[T]) -> Bool {
 /// arr.rollback_to(snapshot1)
 /// inspect(arr.length(), content="0")
 /// ```
-pub fn[T] commit(self : SnapshotArray[T], snapshot : Snapshot) -> Unit {
+pub fn[T] SnapshotArray::commit(
+  self : SnapshotArray[T],
+  snapshot : Snapshot,
+) -> Unit {
   self.logs.commit(snapshot.undo_count)
 }
 
@@ -355,7 +374,7 @@ pub fn[T] commit(self : SnapshotArray[T], snapshot : Snapshot) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let arr = new()
 /// let _snapshot = arr.start_snapshot()
 /// arr.push(1)
@@ -365,12 +384,12 @@ pub fn[T] commit(self : SnapshotArray[T], snapshot : Snapshot) -> Unit {
 /// inspect(arr.in_snapshot(), content="false")
 /// inspect(arr.length(), content="2")
 /// ```
-pub fn[T] commit_all(self : SnapshotArray[T]) -> Unit {
+pub fn[T] SnapshotArray::commit_all(self : SnapshotArray[T]) -> Unit {
   self.logs.clear()
 }
 
 ///|
-pub fn[T] op_get(self : SnapshotArray[T], index : Int) -> T {
+pub fn[T] SnapshotArray::op_get(self : SnapshotArray[T], index : Int) -> T {
   if index < 0 || index >= self.values.length() {
     abort("Index out of bounds")
   }
@@ -378,7 +397,11 @@ pub fn[T] op_get(self : SnapshotArray[T], index : Int) -> T {
 }
 
 ///|
-pub fn[T] op_set(self : SnapshotArray[T], index : Int, value : T) -> Unit {
+pub fn[T] SnapshotArray::op_set(
+  self : SnapshotArray[T],
+  index : Int,
+  value : T,
+) -> Unit {
   if index < 0 || index >= self.values.length() {
     abort("Index out of bounds")
   }
diff --git a/src/snapshot_array/snapshot_array_test.mbt b/src/snapshot_array/snapshot_array_test.mbt
index d424cae..a780481 100644
--- a/src/snapshot_array/snapshot_array_test.mbt
+++ b/src/snapshot_array/snapshot_array_test.mbt
@@ -17,7 +17,7 @@ test "SnapshotArray::length" {
 }
 
 ///|
-test "SnapshotArray::get" {
+test "SnapshotArray::get_with_snapshot" {
   let arr = new(capacity=5)
   arr.push(1)
   arr.push(2)
diff --git a/src/undo_logs/moon.pkg b/src/undo_logs/moon.pkg
new file mode 100644
index 0000000..2c3bbc4
--- /dev/null
+++ b/src/undo_logs/moon.pkg
@@ -0,0 +1,3 @@
+options(
+  name: "BigOrangeQWQ/unification_table/undo_logs",
+)
diff --git a/src/undo_logs/moon.pkg.json b/src/undo_logs/moon.pkg.json
deleted file mode 100644
index b52ad3d..0000000
--- a/src/undo_logs/moon.pkg.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "name": "BigOrangeQWQ/unification_table/undo_logs"
-}
\ No newline at end of file
diff --git a/src/undo_logs/pkg.generated.mbti b/src/undo_logs/pkg.generated.mbti
new file mode 100644
index 0000000..85eb9e2
--- /dev/null
+++ b/src/undo_logs/pkg.generated.mbti
@@ -0,0 +1,46 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "BigOrangeQWQ/unification_table/undo_logs"
+
+// Values
+pub fn[T] from_iter(Iter[Undo[T]], capacity? : Int) -> UndoLogs[T]
+
+pub fn[T] new(capacity? : Int) -> UndoLogs[T]
+
+pub fn[T] newElem(Int) -> Undo[T]
+
+pub fn[T] setElem(Int, T) -> Undo[T]
+
+// Errors
+
+// Types and methods
+pub enum Undo[T] {
+  NewElem(Int)
+  SetElem(Int, T)
+}
+pub impl[T : Eq] Eq for Undo[T]
+pub impl[T : Show] Show for Undo[T]
+
+pub struct UndoLogs[T] {
+  logs : Array[Undo[T]]
+  mut num_open_snapshots : Int
+}
+pub fn[T] UndoLogs::action_since_snapshot(Self[T], Int) -> ArrayView[Undo[T]]
+pub fn[T] UndoLogs::clear(Self[T]) -> Unit
+pub fn[T] UndoLogs::commit(Self[T], Int) -> Unit
+pub fn[T] UndoLogs::extend(Self[T], Iter[Undo[T]]) -> Unit
+pub fn[T] UndoLogs::has_changes(Self[T], Int) -> Bool
+pub fn[T] UndoLogs::in_snapshot(Self[T]) -> Bool
+pub fn[T] UndoLogs::iter(Self[T]) -> Iter[Undo[T]]
+pub fn[T] UndoLogs::last(Self[T]) -> Undo[T]?
+pub fn[T] UndoLogs::length(Self[T]) -> Int
+pub fn[T] UndoLogs::num_open_snapshots(Self[T]) -> Int
+pub fn[T] UndoLogs::pop(Self[T]) -> Undo[T]?
+pub fn[T] UndoLogs::push(Self[T], Undo[T]) -> Unit
+pub fn[T] UndoLogs::rollback_to(Self[T], Int) -> Array[Undo[T]]
+pub fn[T] UndoLogs::start_snapshot(Self[T]) -> Int
+
+// Type aliases
+pub type Snapshot = Int
+
+// Traits
+
diff --git a/src/undo_logs/undo_logs.mbt b/src/undo_logs/undo_logs.mbt
index 2f953e8..cdabf1c 100644
--- a/src/undo_logs/undo_logs.mbt
+++ b/src/undo_logs/undo_logs.mbt
@@ -6,7 +6,7 @@ pub enum Undo[T] {
 }
 
 ///|
-typealias Int as Snapshot
+pub type Snapshot = Int
 
 ///|
 pub fn[T] newElem(index : Int) -> Undo[T] {
@@ -43,7 +43,7 @@ pub fn[T] from_iter(iter : Iter[Undo[T]], capacity? : Int = 0) -> UndoLogs[T] {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
@@ -51,7 +51,7 @@ pub fn[T] from_iter(iter : Iter[Undo[T]], capacity? : Int = 0) -> UndoLogs[T] {
 /// let _ = logs.start_snapshot()
 /// assert_true(logs.in_snapshot())
 /// ```
-pub fn[T] in_snapshot(self : UndoLogs[T]) -> Bool {
+pub fn[T] UndoLogs::in_snapshot(self : UndoLogs[T]) -> Bool {
   self.num_open_snapshots > 0
 }
 
@@ -60,13 +60,13 @@ pub fn[T] in_snapshot(self : UndoLogs[T]) -> Bool {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
 /// assert_eq(logs.length(), 2)
 /// ```
-pub fn[T] length(self : UndoLogs[T]) -> Int {
+pub fn[T] UndoLogs::length(self : UndoLogs[T]) -> Int {
   self.logs.length()
 }
 
@@ -75,7 +75,7 @@ pub fn[T] length(self : UndoLogs[T]) -> Int {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let _ = logs.start_snapshot()
 /// assert_true(logs.num_open_snapshots() == 1)
@@ -84,7 +84,7 @@ pub fn[T] length(self : UndoLogs[T]) -> Int {
 /// logs.push(setElem(1, "test"))
 /// logs.commit(s1)
 /// ```
-pub fn[T] num_open_snapshots(self : UndoLogs[T]) -> Int {
+pub fn[T] UndoLogs::num_open_snapshots(self : UndoLogs[T]) -> Int {
   self.num_open_snapshots
 }
 
@@ -93,13 +93,13 @@ pub fn[T] num_open_snapshots(self : UndoLogs[T]) -> Int {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
 /// assert_eq(logs.length(), 2)
 /// ```
-pub fn[T] push(self : UndoLogs[T], log : Undo[T]) -> Unit {
+pub fn[T] UndoLogs::push(self : UndoLogs[T], log : Undo[T]) -> Unit {
   self.logs.push(log)
 }
 
@@ -108,7 +108,7 @@ pub fn[T] push(self : UndoLogs[T], log : Undo[T]) -> Unit {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let _ = logs.start_snapshot()
 /// logs.push(newElem(0))
@@ -118,7 +118,7 @@ pub fn[T] push(self : UndoLogs[T], log : Undo[T]) -> Unit {
 /// assert_true(logs.logs.length() == 0)
 /// assert_true(logs.num_open_snapshots == 0)
 /// ```
-pub fn[T] clear(self : UndoLogs[T]) -> Unit {
+pub fn[T] UndoLogs::clear(self : UndoLogs[T]) -> Unit {
   self.logs.clear()
   self.num_open_snapshots = 0
 }
@@ -128,7 +128,7 @@ pub fn[T] clear(self : UndoLogs[T]) -> Unit {
 ///
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 ///  let logs = new()
 ///  let new_logs = [newElem(0), setElem(1, "test")]
 ///  logs.extend(new_logs.iter())
@@ -136,7 +136,7 @@ pub fn[T] clear(self : UndoLogs[T]) -> Unit {
 ///  inspect(logs.logs[0], content="NewElem(0)")
 ///  inspect(logs.logs[1], content="SetElem(1, test)")
 /// ```
-pub fn[T] extend(self : UndoLogs[T], logs : Iter[Undo[T]]) -> Unit {
+pub fn[T] UndoLogs::extend(self : UndoLogs[T], logs : Iter[Undo[T]]) -> Unit {
   logs.each(fn(log) { self.push(log) })
 }
 
@@ -147,7 +147,7 @@ pub fn[T] extend(self : UndoLogs[T], logs : Iter[Undo[T]]) -> Unit {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let s1 = logs.start_snapshot()
 /// logs.push(newElem(0))
@@ -157,7 +157,7 @@ pub fn[T] extend(self : UndoLogs[T], logs : Iter[Undo[T]]) -> Unit {
 /// inspect(actions[0], content="NewElem(0)")
 /// inspect(actions[1], content="SetElem(1, test)")
 /// ```
-pub fn[T] action_since_snapshot(
+pub fn[T] UndoLogs::action_since_snapshot(
   self : UndoLogs[T],
   snapshot : Snapshot,
 ) -> ArrayView[Undo[T]] {
@@ -169,14 +169,17 @@ pub fn[T] action_since_snapshot(
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let s1 = logs.start_snapshot()
 /// assert_false(logs.has_changes(s1))
 /// logs.push(setElem(2, "another_test"))
 /// assert_true(logs.has_changes(s1))
 /// ```
-pub fn[T] has_changes(self : UndoLogs[T], snapshot : Snapshot) -> Bool {
+pub fn[T] UndoLogs::has_changes(
+  self : UndoLogs[T],
+  snapshot : Snapshot,
+) -> Bool {
   self.action_since_snapshot(snapshot).length() > 0
 }
 
@@ -185,21 +188,24 @@ pub fn[T] has_changes(self : UndoLogs[T], snapshot : Snapshot) -> Bool {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let s1 = logs.start_snapshot()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
 /// inspect(logs.action_since_snapshot(s1), content="[NewElem(0), SetElem(1, test)]")
 /// ```
-pub fn[T] start_snapshot(self : UndoLogs[T]) -> Snapshot {
+pub fn[T] UndoLogs::start_snapshot(self : UndoLogs[T]) -> Snapshot {
   self.num_open_snapshots += 1
   self.logs.length()
 }
 
 ///|
 /// Asserts that the given snapshot is valid.
-fn[T] assert_valid_snapshot(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
+fn[T] UndoLogs::assert_valid_snapshot(
+  self : UndoLogs[T],
+  snapshot : Snapshot,
+) -> Unit {
   guard self.logs.length() > snapshot else { abort("Invalid snapshot") }
   guard self.num_open_snapshots > 0 else { abort("No open snapshots") }
 }
@@ -210,7 +216,7 @@ fn[T] assert_valid_snapshot(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let s1 = logs.start_snapshot()
 /// logs.push(newElem(0))
@@ -218,7 +224,7 @@ fn[T] assert_valid_snapshot(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
 /// logs.commit(s1)
 /// assert_eq(logs.length(), 0)
 /// ```
-pub fn[T] commit(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
+pub fn[T] UndoLogs::commit(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
   self.assert_valid_snapshot(snapshot)
   if self.num_open_snapshots == 1 {
     // The root snapshot. It's safe to clear the undo log because
@@ -235,7 +241,7 @@ pub fn[T] commit(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// let _ = logs.start_snapshot()
 /// logs.push(newElem(0))
@@ -248,7 +254,7 @@ pub fn[T] commit(self : UndoLogs[T], snapshot : Snapshot) -> Unit {
 ///   content="[SetElem(3, another_rollback_test), NewElem(4)]",
 /// )
 /// ```
-pub fn[T] rollback_to(
+pub fn[T] UndoLogs::rollback_to(
   self : UndoLogs[T],
   snapshot : Snapshot,
 ) -> Array[Undo[T]] {
@@ -256,7 +262,6 @@ pub fn[T] rollback_to(
   let logs = self.action_since_snapshot(snapshot).to_array()
   for _ in 0..<logs.length() {
     let _ = self.pop()
-
   }
   logs
 }
@@ -266,7 +271,7 @@ pub fn[T] rollback_to(
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
@@ -274,7 +279,7 @@ pub fn[T] rollback_to(
 /// assert_eq(popped, setElem(1, "test"))
 /// assert_eq(logs.length(), 1)
 /// ```
-pub fn[T] pop(self : UndoLogs[T]) -> Undo[T]? {
+pub fn[T] UndoLogs::pop(self : UndoLogs[T]) -> Undo[T]? {
   self.logs.pop()
 }
 
@@ -283,24 +288,24 @@ pub fn[T] pop(self : UndoLogs[T]) -> Undo[T]? {
 /// 
 /// Example:
 /// 
-/// ```moonbit
+/// ```moonbit nocheck
 /// let logs = new()
 /// logs.push(newElem(0))
 /// logs.push(setElem(1, "test"))
 /// let last = logs.last().unwrap()
 /// assert_eq(last, setElem(1, "test"))
 /// ```
-pub fn[T] last(self : UndoLogs[T]) -> Undo[T]? {
+pub fn[T] UndoLogs::last(self : UndoLogs[T]) -> Undo[T]? {
   self.logs.last()
 }
 
 ///|
-pub fn[T] iter(self : UndoLogs[T]) -> Iter[Undo[T]] {
+pub fn[T] UndoLogs::iter(self : UndoLogs[T]) -> Iter[Undo[T]] {
   self.logs.iter()
 }
 
 ///|
-pub impl[T : Eq] Eq for Undo[T] with op_equal(self, other : Undo[T]) -> Bool {
+pub impl[T : Eq] Eq for Undo[T] with equal(self, other : Undo[T]) -> Bool {
   match (self, other) {
     (NewElem(index1), NewElem(index2)) => index1 == index2
     (SetElem(index1, value1), SetElem(index2, value2)) =>
diff --git a/src/undo_logs/undo_logs_test.mbt b/src/undo_logs/undo_logs_test.mbt
index b9a50e0..aa3b09b 100644
--- a/src/undo_logs/undo_logs_test.mbt
+++ b/src/undo_logs/undo_logs_test.mbt
@@ -24,7 +24,7 @@ test "UndoLogs::length" {
 }
 
 ///|
-test "UndoLogs::num_open_snapshots" {
+test "UndoLogs::num_open_snapshots_nested" {
   let logs = new()
   let _ = logs.start_snapshot()
   assert_true(logs.num_open_snapshots() == 1)
diff --git a/src/unify_table/moon.pkg b/src/unify_table/moon.pkg
new file mode 100644
index 0000000..4e5c054
--- /dev/null
+++ b/src/unify_table/moon.pkg
@@ -0,0 +1,7 @@
+import {
+  "BigOrangeQWQ/unification_table/snapshot_array",
+}
+
+options(
+  name: "BigOrangeQWQ/unification_table/unify_table",
+)
diff --git a/src/unify_table/moon.pkg.json b/src/unify_table/moon.pkg.json
deleted file mode 100644
index e06c8c4..0000000
--- a/src/unify_table/moon.pkg.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "name": "BigOrangeQWQ/unification_table/unify_table",
-    "import": [
-      "BigOrangeQWQ/unification_table/snapshot_array"
-    ]
-}
\ No newline at end of file
diff --git a/src/unify_table/pkg.generated.mbti b/src/unify_table/pkg.generated.mbti
new file mode 100644
index 0000000..9acee9d
--- /dev/null
+++ b/src/unify_table/pkg.generated.mbti
@@ -0,0 +1,67 @@
+// Generated using `moon info`, DON'T EDIT IT
+package "BigOrangeQWQ/unification_table/unify_table"
+
+import {
+  "BigOrangeQWQ/unification_table/snapshot_array",
+}
+
+// Values
+pub fn[T] new(capacity~ : Int) -> UnificationTable[T]
+
+pub fn new_index(Int) -> VarIndex
+
+pub fn new_snapshot(@snapshot_array.Snapshot) -> Snapshot
+
+pub fn[T] new_var_value(T, Int, VarIndex) -> VarValue[T]
+
+// Errors
+
+// Types and methods
+pub struct Snapshot {
+  snapshot : @snapshot_array.Snapshot
+}
+
+pub struct UnificationTable[T] {
+  values : @snapshot_array.SnapshotArray[VarValue[T]]
+}
+pub fn[T] UnificationTable::commit(Self[T], Snapshot) -> Unit
+pub fn[T] UnificationTable::find(Self[T], VarIndex) -> VarIndex
+pub fn[T] UnificationTable::find_root(Self[T], VarValue[T]) -> VarValue[T]
+pub fn[T] UnificationTable::get(Self[T], Int) -> VarValue[T]?
+pub fn[T] UnificationTable::in_snapshot(Self[T]) -> Bool
+pub fn[T] UnificationTable::index(Self[T], Int) -> VarIndex
+pub fn[T] UnificationTable::op_get(Self[T], Int) -> VarValue[T]
+pub fn[T] UnificationTable::op_set(Self[T], Int, VarValue[T]) -> Unit
+pub fn[T] UnificationTable::push(Self[T], T) -> Unit
+pub fn[T] UnificationTable::push_var(Self[T], VarValue[T]) -> Unit
+pub fn[T] UnificationTable::redirect_root(Self[T], Int, VarIndex, VarIndex, T) -> Unit
+pub fn[T] UnificationTable::reset(Self[T]) -> Unit
+pub fn[T] UnificationTable::rollback_to(Self[T], Snapshot) -> Unit
+pub fn[T] UnificationTable::set(Self[T], VarIndex, VarValue[T]) -> Unit
+pub fn[T] UnificationTable::start_snapshot(Self[T]) -> Snapshot
+pub fn[T] UnificationTable::unioned(Self[T], VarIndex, VarIndex) -> Bool
+pub fn[T] UnificationTable::unite(Self[T], VarIndex, VarIndex, T) -> VarIndex
+pub fn[T] UnificationTable::update(Self[T], VarIndex, (VarValue[T]) -> VarValue[T]) -> Unit
+pub fn[T] UnificationTable::value(Self[T], VarIndex) -> VarValue[T]
+pub impl[T : Show] Show for UnificationTable[T]
+
+pub struct VarIndex {
+  index : Int
+}
+pub impl Show for VarIndex
+
+pub struct VarValue[T] {
+  mut value : T
+  mut rank : Int
+  mut parent : VarIndex
+}
+pub fn[T] VarValue::modify(Self[T], T) -> Unit
+pub fn[T] VarValue::redirect(Self[T], VarIndex) -> Self[T]
+pub fn[T] VarValue::root(Self[T], Int, T) -> Self[T]
+pub impl[T : Eq] Eq for VarValue[T]
+pub impl[T : Show] Show for VarValue[T]
+
+// Type aliases
+
+// Traits
+
diff --git a/src/unify_table/unify_table.mbt b/src/unify_table/unify_table.mbt
index 1187aae..2eb1efe 100644
--- a/src/unify_table/unify_table.mbt
+++ b/src/unify_table/unify_table.mbt
@@ -34,7 +34,7 @@ pub struct VarValue[T] {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let index = new_index(0)
 /// let var_value = new_var_value(42, 0, index)
 /// inspect(var_value.value, content="42")
@@ -58,14 +58,14 @@ pub fn[T] new_var_value(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let old_parent = new_index(0)
 /// let new_parent = new_index(1)
 /// let var_value = new_var_value(42, 0, old_parent)
 /// let var_value = var_value.redirect(new_parent)
 /// inspect(var_value.parent.index, content="1")
 /// ```
-pub fn[T] redirect(self : VarValue[T], to : VarIndex) -> VarValue[T] {
+pub fn[T] VarValue::redirect(self : VarValue[T], to : VarIndex) -> VarValue[T] {
   new_var_value(self.value, self.rank, to)
 }
 
@@ -79,14 +79,18 @@ pub fn[T] redirect(self : VarValue[T], to : VarIndex) -> VarValue[T] {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let index = new_index(0)
 /// let var_value = new_var_value(42, 0, index)
 /// let var_value = var_value.root(1, 100)
 /// inspect(var_value.value, content="100")
 /// inspect(var_value.rank, content="1")
 /// ```
-pub fn[T] root(self : VarValue[T], rank : Int, value : T) -> VarValue[T] {
+pub fn[T] VarValue::root(
+  self : VarValue[T],
+  rank : Int,
+  value : T,
+) -> VarValue[T] {
   new_var_value(value, rank, self.parent)
 }
 
@@ -97,13 +101,13 @@ pub fn[T] root(self : VarValue[T], rank : Int, value : T) -> VarValue[T] {
 /// * `value`: The new value of type `T` to be stored.
 /// 
 /// Example:
-/// ```moonbit
+/// ```moonbit nocheck
 /// let index = new_index(0)
 /// let var_value = new_var_value(42, 0, index)
 /// var_value.modify(100)
 /// inspect(var_value.value, content="100")
 /// ```
-pub fn[T] modify(self : VarValue[T], value : T) -> Unit {
+pub fn[T] VarValue::modify(self : VarValue[T], value : T) -> Unit {
   self.value = value
 }
 
@@ -120,13 +124,13 @@ pub fn new_snapshot(snapshot : @snapshot_array.Snapshot) -> Snapshot {
 }
 
 ///|
-pub impl[T : Eq] Eq for VarValue[T] with op_equal(self, other) {
-  return self.value == other.value && self.parent == other.parent
+pub impl[T : Eq] Eq for VarValue[T] with equal(self, other) {
+  self.value == other.value && self.parent == other.parent
 }
 
 ///|
-impl Eq for VarIndex with op_equal(self, other) {
-  return self.index == other.index
+impl Eq for VarIndex with equal(self, other) {
+  self.index == other.index
 }
 
 ///|
@@ -139,7 +143,7 @@ impl Eq for VarIndex with op_equal(self, other) {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=10)
 /// inspect(table.values.length(), content="0")
 /// ```
@@ -157,12 +161,12 @@ pub fn[T] new(capacity~ : Int) -> UnificationTable[T] {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table = new(capacity=5)
 /// table.push(1)
 /// assert_true(table.values.length() == 1)
 /// ```
-pub fn[T] push(self : UnificationTable[T], value : T) -> Unit {
+pub fn[T] UnificationTable::push(self : UnificationTable[T], value : T) -> Unit {
   self.values.push({ value, rank: 0, parent: new_index(self.values.length()) })
 }
 
@@ -177,13 +181,16 @@ pub fn[T] push(self : UnificationTable[T], value : T) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// let var_value = new_var_value(42, 0, new_index(0))
 /// table.push_var(var_value)
 /// inspect(table.values.length(), content="1")
 /// ```
-pub fn[T] push_var(self : UnificationTable[T], value : VarValue[T]) -> Unit {
+pub fn[T] UnificationTable::push_var(
+  self : UnificationTable[T],
+  value : VarValue[T],
+) -> Unit {
   self.values.push(value)
 }
 
@@ -199,7 +206,7 @@ pub fn[T] push_var(self : UnificationTable[T], value : VarValue[T]) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// inspect(
@@ -208,7 +215,10 @@ pub fn[T] push_var(self : UnificationTable[T], value : VarValue[T]) -> Unit {
 /// )
 /// inspect(table.get(1), content="None")
 /// ```
-pub fn[T] get(self : UnificationTable[T], index : Int) -> VarValue[T]? {
+pub fn[T] UnificationTable::get(
+  self : UnificationTable[T],
+  index : Int,
+) -> VarValue[T]? {
   self.values.get(index)
 }
 
@@ -226,12 +236,15 @@ pub fn[T] get(self : UnificationTable[T], index : Int) -> VarValue[T]? {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// inspect(table.index(0).index, content="0")
 /// ```
-pub fn[T] index(self : UnificationTable[T], index : Int) -> VarIndex {
+pub fn[T] UnificationTable::index(
+  self : UnificationTable[T],
+  index : Int,
+) -> VarIndex {
   if index < 0 || index >= self.values.length() {
     abort("Index out of bounds")
   }
@@ -248,7 +261,7 @@ pub fn[T] index(self : UnificationTable[T], index : Int) -> VarIndex {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// let index = new_index(0)
@@ -257,7 +270,10 @@ pub fn[T] index(self : UnificationTable[T], index : Int) -> VarIndex {
 ///   content="VarValue { value: 42, rank: 0, parent: VarIndex { index: 0 } }",
 /// )
 /// ```
-pub fn[T] value(self : UnificationTable[T], index : VarIndex) -> VarValue[T] {
+pub fn[T] UnificationTable::value(
+  self : UnificationTable[T],
+  index : VarIndex,
+) -> VarValue[T] {
   self.get(index.index).unwrap()
 }
 
@@ -268,7 +284,7 @@ pub fn[T] value(self : UnificationTable[T], index : VarIndex) -> VarValue[T] {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=2)
 /// table.push(1)
 /// table.push(2)
@@ -279,7 +295,7 @@ pub fn[T] value(self : UnificationTable[T], index : VarIndex) -> VarValue[T] {
 ///   content="false",
 /// )
 /// ```
-pub fn[T] reset(self : UnificationTable[T]) -> Unit {
+pub fn[T] UnificationTable::reset(self : UnificationTable[T]) -> Unit {
   for index, value in self.values.values {
     value.rank = 0
     value.parent = new_index(index)
@@ -298,7 +314,7 @@ pub fn[T] reset(self : UnificationTable[T]) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// let new_value = new_var_value(100, 0, new_index(0))
@@ -308,7 +324,7 @@ pub fn[T] reset(self : UnificationTable[T]) -> Unit {
 ///   content="Some(VarValue { value: 100, rank: 0, parent: VarIndex { index: 0 } })",
 /// )
 /// ```
-pub fn[T] set(
+pub fn[T] UnificationTable::set(
   self : UnificationTable[T],
   index : VarIndex,
   value : VarValue[T],
@@ -327,7 +343,7 @@ pub fn[T] set(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// table.update(new_index(0), fn(val) { val.modify(100); val })
@@ -336,7 +352,7 @@ pub fn[T] set(
 ///   content="Some(VarValue { value: 100, rank: 0, parent: VarIndex { index: 0 } })",
 /// )
 /// ```
-pub fn[T] update(
+pub fn[T] UnificationTable::update(
   self : UnificationTable[T],
   index : VarIndex,
   func : (VarValue[T]) -> VarValue[T],
@@ -358,14 +374,14 @@ pub fn[T] update(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=2)
 /// table.push(1)
 /// table.push(2)
 /// table.redirect_root(1, new_index(0), new_index(1), 42)
 /// inspect(table.find(new_index(0)).index, content="1")
 /// ```
-pub fn[T] redirect_root(
+pub fn[T] UnificationTable::redirect_root(
   self : UnificationTable[T],
   new_rank : Int,
   old_index : VarIndex,
@@ -389,7 +405,7 @@ pub fn[T] redirect_root(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=2)
 /// table.push(1)
 /// table.push(2)
@@ -399,7 +415,7 @@ pub fn[T] redirect_root(
 ///   content="true",
 /// )
 /// ```
-pub fn[T] unioned(
+pub fn[T] UnificationTable::unioned(
   self : UnificationTable[T],
   index1 : VarIndex,
   index2 : VarIndex,
@@ -422,14 +438,14 @@ pub fn[T] unioned(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=2)
 /// table.push(1)
 /// table.push(2)
 /// let root = table.unite(table.index(0),table.index(1), 42)
 /// inspect(table.value(root).value, content="42")
 /// ```
-pub fn[T] unite(
+pub fn[T] UnificationTable::unite(
   self : UnificationTable[T],
   index1 : VarIndex,
   index2 : VarIndex,
@@ -467,7 +483,7 @@ pub fn[T] unite(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=3)
 /// table.push(1)
 /// table.push(2)
@@ -476,7 +492,10 @@ pub fn[T] unite(
 /// let root = table.find(table.index(0))
 /// inspect(root.index, content="0")
 /// ```
-pub fn[T] find(self : UnificationTable[T], index : VarIndex) -> VarIndex {
+pub fn[T] UnificationTable::find(
+  self : UnificationTable[T],
+  index : VarIndex,
+) -> VarIndex {
   let value = self.value(index)
   if value.parent == index {
     return index
@@ -501,7 +520,7 @@ pub fn[T] find(self : UnificationTable[T], index : VarIndex) -> VarIndex {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=2)
 /// table.push(1)
 /// table.push(2)
@@ -510,7 +529,7 @@ pub fn[T] find(self : UnificationTable[T], index : VarIndex) -> VarIndex {
 /// let root = table.find_root(value)
 /// inspect(root.value, content="42")
 /// ```
-pub fn[T] find_root(
+pub fn[T] UnificationTable::find_root(
   self : UnificationTable[T],
   value : VarValue[T],
 ) -> VarValue[T] {
@@ -525,12 +544,12 @@ pub fn[T] find_root(
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// let _ = table.start_snapshot()
 /// assert_true(table.in_snapshot())
 /// ```
-pub fn[T] in_snapshot(self : UnificationTable[T]) -> Bool {
+pub fn[T] UnificationTable::in_snapshot(self : UnificationTable[T]) -> Bool {
   self.values.in_snapshot()
 }
 
@@ -541,7 +560,7 @@ pub fn[T] in_snapshot(self : UnificationTable[T]) -> Bool {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// let snapshot = table.start_snapshot()
@@ -549,7 +568,9 @@ pub fn[T] in_snapshot(self : UnificationTable[T]) -> Bool {
 /// table.rollback_to(snapshot)
 /// inspect(table.values.length(), content="1")
 /// ```
-pub fn[T] start_snapshot(self : UnificationTable[T]) -> Snapshot {
+pub fn[T] UnificationTable::start_snapshot(
+  self : UnificationTable[T],
+) -> Snapshot {
   let snapshot = self.values.start_snapshot()
   new_snapshot(snapshot)
 }
@@ -565,7 +586,7 @@ pub fn[T] start_snapshot(self : UnificationTable[T]) -> Snapshot {
 /// 
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// let snapshot = table.start_snapshot()
@@ -573,7 +594,10 @@ pub fn[T] start_snapshot(self : UnificationTable[T]) -> Snapshot {
 /// table.rollback_to(snapshot)
 /// inspect(table.values.length(), content="1")
 /// ```
-pub fn[T] rollback_to(self : UnificationTable[T], snapshot : Snapshot) -> Unit {
+pub fn[T] UnificationTable::rollback_to(
+  self : UnificationTable[T],
+  snapshot : Snapshot,
+) -> Unit {
   self.values.rollback_to(snapshot.snapshot)
 }
 
@@ -587,7 +611,7 @@ pub fn[T] rollback_to(self : UnificationTable[T], snapshot : Snapshot) -> Unit {
 ///
 /// Example:
 ///
-/// ```moonbit
+/// ```moonbit nocheck
 /// let table : UnificationTable[Int] = new(capacity=5)
 /// table.push(42)
 /// let snapshot = table.start_snapshot()
@@ -595,17 +619,23 @@ pub fn[T] rollback_to(self : UnificationTable[T], snapshot : Snapshot) -> Unit {
 /// table.commit(snapshot)
 /// inspect(table.values.length(), content="2")
 /// ```
-pub fn[T] commit(self : UnificationTable[T], snapshot : Snapshot) -> Unit {
+pub fn[T] UnificationTable::commit(
+  self : UnificationTable[T],
+  snapshot : Snapshot,
+) -> Unit {
   self.values.commit(snapshot.snapshot)
 }
 
 ///|
-pub fn[T] op_get(self : UnificationTable[T], index : Int) -> VarValue[T] {
+pub fn[T] UnificationTable::op_get(
+  self : UnificationTable[T],
+  index : Int,
+) -> VarValue[T] {
   return self.get(index).unwrap()
 }
 
 ///|
-pub fn[T] op_set(
+pub fn[T] UnificationTable::op_set(
   self : UnificationTable[T],
   index : Int,
   value : VarValue[T],
@@ -622,7 +652,7 @@ pub impl[T : Show] Show for VarValue[T] with output(self, logger : &Logger) {
   ..write_object(self.rank)
   ..write_string(", parent: ")
   ..write_object(self.parent)
-  ..write_string(" }")
+  .write_string(" }")
 }
 
 ///|
@@ -630,7 +660,7 @@ pub impl Show for VarIndex with output(self, logger : &Logger) {
   logger
   ..write_string("VarIndex { index: ")
   ..write_object(self.index)
-  ..write_string(" }")
+  .write_string(" }")
 }
 
 ///|
diff --git a/src/unify_table/unify_table_test.mbt b/src/unify_table/unify_table_test.mbt
index 6ffc362..56fe29d 100644
--- a/src/unify_table/unify_table_test.mbt
+++ b/src/unify_table/unify_table_test.mbt
@@ -41,7 +41,6 @@ test "UnificationTable::index" {
 test "panic UnificationTable::index/out_of_bounds" {
   let table : UnificationTable[Int] = new(capacity=5)
   let _ = table.index(-1)
-
 }
 
 ///|