From 7a1366ecf283e92471f80bca3020b052b1ba69be Mon Sep 17 00:00:00 2001
From: rami3l <rami3l@outlook.com>
Date: Mon, 9 Jun 2025 15:03:23 +0800
Subject: [PATCH 1/4] style: reformat codebase

---
 src/js/async.mbt            |  24 ++-
 src/js/async_deprecated.mbt |   4 +-
 src/js/error.mbt            |   2 +-
 src/js/js.mbti              | 318 +++++++++++++++++-------------------
 src/js/null.mbt             |  10 +-
 src/js/object.mbt           |  20 ++-
 src/js/optional.mbt         |  10 +-
 src/js/require.mbt          |   2 +-
 src/js/union.mbt            | 140 ++++++++--------
 src/js/value.mbt            |  32 ++--
 10 files changed, 269 insertions(+), 293 deletions(-)

diff --git a/src/js/async.mbt b/src/js/async.mbt
index 849c97d..44718eb 100644
--- a/src/js/async.mbt
+++ b/src/js/async.mbt
@@ -1,10 +1,10 @@
 ///|
-pub async fn suspend[T, E : Error](
+pub async fn[T, E : Error] suspend(
   f : ((T) -> Unit, (E) -> Unit) -> Unit
 ) -> T!E = "%async.suspend"
 
 ///|
-pub fn async_run(f : () -> Unit!Async) -> Unit = "%async.run"
+pub fn async_run(f : async () -> Unit) -> Unit = "%async.run"
 
 ///|
 /// # Safety
@@ -38,20 +38,18 @@ pub async fn Promise::wait(self : Promise) -> Value! {
 /// This makes sure that when `op` errs out, the error is caught by the MoonBit runtime.
 ///
 /// If you don't care about the result of the operation, you can use `spawn_detach` instead.
-pub fn Promise::unsafe_new[T](op : () -> T!Error + Async) -> Promise {
+pub fn[T] Promise::unsafe_new(op : async () -> T!) -> Promise {
   Promise::new_ffi(fn() { Value::cast_from(op!()) })
 }
 
 ///|
-extern "js" fn Promise::new_ffi(op : () -> Value!Error + Async) -> Promise =
+extern "js" fn Promise::new_ffi(op : async () -> Value!) -> Promise =
   #| (op) => new Promise((k, ke) => op(k, ke))
 
 ///|
-pub fn spawn_detach[T, E : Error](op : () -> T!E + Async) -> Unit {
+pub fn[T, E : Error] spawn_detach(op : async () -> T!E) -> Unit {
   async_run(fn() {
-    try {
-      op!() |> ignore
-    } catch {
+    try op!() |> ignore catch {
       _ => ()
     }
   })
@@ -64,23 +62,21 @@ pub extern "js" fn Promise::all(promises : Array[Promise]) -> Promise = "(ps) =>
 
 ///|
 /// Wraps each given `async fn` in a `Promise` and waits for all of them to resolve.
-pub async fn async_all![T](ops : Array[() -> T!Error + Async]) -> Array[T] {
+pub async fn[T] async_all!(ops : Array[async () -> T!]) -> Array[T] {
   async_all_raw!(ops.map(fn(op) { async fn!() { Value::cast_from(op!()) } })).map(
     Value::cast,
   )
 }
 
 ///|
-async fn async_all_raw!(ops : Array[() -> Value!Error + Async]) -> Array[Value] {
+async fn async_all_raw!(ops : Array[async () -> Value!]) -> Array[Value] {
   Promise::all(ops.map(Promise::unsafe_new)).wait!().cast()
 }
 
 ///|
-pub fn async_test(op : () -> Unit!Error + Async) -> Unit {
+pub fn async_test(op : async () -> Unit!) -> Unit {
   async_run(async fn() {
-    try {
-      op!()
-    } catch {
+    try op!() catch {
       e => {
         println("ERROR in `async_test`: \{e}")
         panic()
diff --git a/src/js/async_deprecated.mbt b/src/js/async_deprecated.mbt
index c05fa8b..c6cf429 100644
--- a/src/js/async_deprecated.mbt
+++ b/src/js/async_deprecated.mbt
@@ -17,12 +17,12 @@ pub async fn async_wrap(op : AsyncOp) -> Value! {
 
 ///|
 #deprecated("use Promise::new instead")
-pub fn async_unwrap[T](op : () -> T!Error + Async) -> Promise {
+pub fn[T] async_unwrap(op : async () -> T!) -> Promise {
   Promise::new_ffi(fn() { Value::cast_from(op!()) })
 }
 
 ///|
 #deprecated("use Promise::unsafe_new instead")
-pub fn Promise::new[T](op : () -> T!Error + Async) -> Promise {
+pub fn[T] Promise::new(op : async () -> T!) -> Promise {
   Promise::unsafe_new(op)
 }
diff --git a/src/js/error.mbt b/src/js/error.mbt
index 8eede11..66bf523 100644
--- a/src/js/error.mbt
+++ b/src/js/error.mbt
@@ -31,7 +31,7 @@ extern "js" fn Error_::wrap_ffi(
   #| (op, on_ok, on_error) => { try { on_ok(op()); } catch (e) { on_error(e); } }
 
 ///|
-pub fn Error_::wrap[T](
+pub fn[T] Error_::wrap(
   op : () -> Value,
   map_ok~ : (Value) -> T = Value::cast
 ) -> T!Error_ {
diff --git a/src/js/js.mbti b/src/js/js.mbti
index 5ab1fcd..a3509d3 100644
--- a/src/js/js.mbti
+++ b/src/js/js.mbti
@@ -1,7 +1,11 @@
 package "rami3l/js-ffi/js"
 
+import(
+  "moonbitlang/core/json"
+)
+
 // Values
-fn async_all[T](Array[() -> T!]) -> Array[T]!
+async fn[T] async_all(Array[() -> T!]) -> Array[T]!
 
 let async_iterator : Symbol
 
@@ -10,18 +14,18 @@ fn async_run(() -> Unit) -> Unit
 fn async_test(() -> Unit!) -> Unit
 
 #deprecated
-fn async_unwrap[T](() -> T!) -> Promise
+fn[T] async_unwrap(() -> T!) -> Promise
 
 #deprecated
-fn async_wrap(() -> Promise) -> Value!
+async fn async_wrap(() -> Promise) -> Value!
 
 fn extends(Value, Value) -> Value
 
-fn get_with_index[T](Value, Int) -> T
+fn[T] get_with_index(Value, Int) -> T
 
-fn get_with_string[T](Value, String) -> T
+fn[T] get_with_string(Value, String) -> T
 
-fn get_with_symbol[T](Value, Symbol) -> T
+fn[T] get_with_symbol(Value, Symbol) -> T
 
 let globalThis : Value
 
@@ -43,206 +47,178 @@ let iterator : Symbol
 
 fn require(String, keys~ : Array[String] = ..) -> Value
 
-fn set_with_index[T](Value, Int, T) -> Unit
+fn[T] set_with_index(Value, Int, T) -> Unit
 
-fn set_with_string[T](Value, String, T) -> Unit
+fn[T] set_with_string(Value, String, T) -> Unit
 
-fn set_with_symbol[T](Value, Symbol, T) -> Unit
+fn[T] set_with_symbol(Value, Symbol, T) -> Unit
 
-fn spawn_detach[T, E : Error](() -> T!E) -> Unit
+fn[T, E : Error] spawn_detach(() -> T!E) -> Unit
 
-fn suspend[T, E : Error](((T) -> Unit, (E) -> Unit) -> Unit) -> T!E
+async fn[T, E : Error] suspend(((T) -> Unit, (E) -> Unit) -> Unit) -> T!E
 
 // Types and methods
 pub type! Error_ Value
-impl Error_ {
-  cause(Self) -> Value?
-  wrap[T](() -> Value, map_ok~ : (Value) -> T = ..) -> T!Self
-}
+fn Error_::cause(Self) -> Value?
+fn[T] Error_::wrap(() -> Value, map_ok~ : (Value) -> T = ..) -> T!Self
 impl Show for Error_
 
 type Nullable[_]
-impl Nullable {
-  from_option[T](T?) -> Self[T]
-  get_exn[T](Self[T]) -> T
-  is_null[T](Self[T]) -> Bool
-  null[T]() -> Self[T]
-  to_option[T](Self[T]) -> T?
-}
+fn[T] Nullable::from_option(T?) -> Self[T]
+fn[T] Nullable::get_exn(Self[T]) -> T
+fn[T] Nullable::is_null(Self[T]) -> Bool
+fn[T] Nullable::null() -> Self[T]
+fn[T] Nullable::to_option(Self[T]) -> T?
 
 pub type Object Value
-impl Object {
-  extend_iter[K, V](Self, Iter[(K, V)]) -> Unit
-  extend_iter2[K, V](Self, Iter2[K, V]) -> Unit
-  extend_object(Self, Self) -> Self
-  from_iter[K, V](Iter[(K, V)]) -> Self
-  from_iter2[K, V](Iter2[K, V]) -> Self
-  from_value(Value) -> Optional[Self]
-  from_value_unchecked(Value) -> Self
-  new() -> Self
-  op_get[K, V](Self, K) -> V
-  op_set[K, V](Self, K, V) -> Unit
-  to_value(Self) -> Value
-}
+fn[K, V] Object::extend_iter(Self, Iter[(K, V)]) -> Unit
+fn[K, V] Object::extend_iter2(Self, Iter2[K, V]) -> Unit
+fn Object::extend_object(Self, Self) -> Self
+fn[K, V] Object::from_iter(Iter[(K, V)]) -> Self
+fn[K, V] Object::from_iter2(Iter2[K, V]) -> Self
+fn Object::from_value(Value) -> Optional[Self]
+fn Object::from_value_unchecked(Value) -> Self
+fn Object::new() -> Self
+fn[K, V] Object::op_get(Self, K) -> V
+fn[K, V] Object::op_set(Self, K, V) -> Unit
+fn Object::to_value(Self) -> Value
 
 type Optional[_]
-impl Optional {
-  from_option[T](T?) -> Self[T]
-  get_exn[T](Self[T]) -> T
-  is_undefined[T](Self[T]) -> Bool
-  to_option[T](Self[T]) -> T?
-  undefined[T]() -> Self[T]
-}
+fn[T] Optional::from_option(T?) -> Self[T]
+fn[T] Optional::get_exn(Self[T]) -> T
+fn[T] Optional::is_undefined(Self[T]) -> Bool
+fn[T] Optional::to_option(Self[T]) -> T?
+fn[T] Optional::undefined() -> Self[T]
 
 pub extern type Promise
-impl Promise {
-  all(Array[Self]) -> Self
-  #deprecated
-  new[T](() -> T!) -> Self
-  unsafe_new[T](() -> T!) -> Self
-  wait(Self) -> Value!
-}
+fn Promise::all(Array[Self]) -> Self
+#deprecated
+fn[T] Promise::new(() -> T!) -> Self
+fn[T] Promise::unsafe_new(() -> T!) -> Self
+async fn Promise::wait(Self) -> Value!
 
 type Symbol
-impl Symbol {
-  make() -> Self
-  make_with_number(Double) -> Self
-  make_with_string(String) -> Self
-  make_with_string_js(String) -> Self
-}
+fn Symbol::make() -> Self
+fn Symbol::make_with_number(Double) -> Self
+fn Symbol::make_with_string(String) -> Self
+fn Symbol::make_with_string_js(String) -> Self
 
 type Union2[_, _]
-impl Union2 {
-  from0[A : Cast, B](A) -> Self[A, B]
-  from1[A, B : Cast](B) -> Self[A, B]
-  to0[A : Cast, B](Self[A, B]) -> A?
-  to1[A, B : Cast](Self[A, B]) -> B?
-}
+fn[A : Cast, B] Union2::from0(A) -> Self[A, B]
+fn[A, B : Cast] Union2::from1(B) -> Self[A, B]
+fn[A : Cast, B] Union2::to0(Self[A, B]) -> A?
+fn[A, B : Cast] Union2::to1(Self[A, B]) -> B?
 
 type Union3[_, _, _]
-impl Union3 {
-  from0[A : Cast, B, C](A) -> Self[A, B, C]
-  from1[A, B : Cast, C](B) -> Self[A, B, C]
-  from2[A, B, C : Cast](C) -> Self[A, B, C]
-  to0[A : Cast, B, C](Self[A, B, C]) -> A?
-  to1[A, B : Cast, C](Self[A, B, C]) -> B?
-  to2[A, B, C : Cast](Self[A, B, C]) -> C?
-}
+fn[A : Cast, B, C] Union3::from0(A) -> Self[A, B, C]
+fn[A, B : Cast, C] Union3::from1(B) -> Self[A, B, C]
+fn[A, B, C : Cast] Union3::from2(C) -> Self[A, B, C]
+fn[A : Cast, B, C] Union3::to0(Self[A, B, C]) -> A?
+fn[A, B : Cast, C] Union3::to1(Self[A, B, C]) -> B?
+fn[A, B, C : Cast] Union3::to2(Self[A, B, C]) -> C?
 
 type Union4[_, _, _, _]
-impl Union4 {
-  from0[A : Cast, B, C, D](A) -> Self[A, B, C, D]
-  from1[A, B : Cast, C, D](B) -> Self[A, B, C, D]
-  from2[A, B, C : Cast, D](C) -> Self[A, B, C, D]
-  from3[A, B, C, D : Cast](D) -> Self[A, B, C, D]
-  to0[A : Cast, B, C, D](Self[A, B, C, D]) -> A?
-  to1[A, B : Cast, C, D](Self[A, B, C, D]) -> B?
-  to2[A, B, C : Cast, D](Self[A, B, C, D]) -> C?
-  to3[A, B, C, D : Cast](Self[A, B, C, D]) -> D?
-}
+fn[A : Cast, B, C, D] Union4::from0(A) -> Self[A, B, C, D]
+fn[A, B : Cast, C, D] Union4::from1(B) -> Self[A, B, C, D]
+fn[A, B, C : Cast, D] Union4::from2(C) -> Self[A, B, C, D]
+fn[A, B, C, D : Cast] Union4::from3(D) -> Self[A, B, C, D]
+fn[A : Cast, B, C, D] Union4::to0(Self[A, B, C, D]) -> A?
+fn[A, B : Cast, C, D] Union4::to1(Self[A, B, C, D]) -> B?
+fn[A, B, C : Cast, D] Union4::to2(Self[A, B, C, D]) -> C?
+fn[A, B, C, D : Cast] Union4::to3(Self[A, B, C, D]) -> D?
 
 type Union5[_, _, _, _, _]
-impl Union5 {
-  from0[A : Cast, B, C, D, E](A) -> Self[A, B, C, D, E]
-  from1[A, B : Cast, C, D, E](B) -> Self[A, B, C, D, E]
-  from2[A, B, C : Cast, D, E](C) -> Self[A, B, C, D, E]
-  from3[A, B, C, D : Cast, E](D) -> Self[A, B, C, D, E]
-  from4[A, B, C, D, E : Cast](E) -> Self[A, B, C, D, E]
-  to0[A : Cast, B, C, D, E](Self[A, B, C, D, E]) -> A?
-  to1[A, B : Cast, C, D, E](Self[A, B, C, D, E]) -> B?
-  to2[A, B, C : Cast, D, E](Self[A, B, C, D, E]) -> C?
-  to3[A, B, C, D : Cast, E](Self[A, B, C, D, E]) -> D?
-  to4[A, B, C, D, E : Cast](Self[A, B, C, D, E]) -> E?
-}
+fn[A : Cast, B, C, D, E] Union5::from0(A) -> Self[A, B, C, D, E]
+fn[A, B : Cast, C, D, E] Union5::from1(B) -> Self[A, B, C, D, E]
+fn[A, B, C : Cast, D, E] Union5::from2(C) -> Self[A, B, C, D, E]
+fn[A, B, C, D : Cast, E] Union5::from3(D) -> Self[A, B, C, D, E]
+fn[A, B, C, D, E : Cast] Union5::from4(E) -> Self[A, B, C, D, E]
+fn[A : Cast, B, C, D, E] Union5::to0(Self[A, B, C, D, E]) -> A?
+fn[A, B : Cast, C, D, E] Union5::to1(Self[A, B, C, D, E]) -> B?
+fn[A, B, C : Cast, D, E] Union5::to2(Self[A, B, C, D, E]) -> C?
+fn[A, B, C, D : Cast, E] Union5::to3(Self[A, B, C, D, E]) -> D?
+fn[A, B, C, D, E : Cast] Union5::to4(Self[A, B, C, D, E]) -> E?
 
 type Union6[_, _, _, _, _, _]
-impl Union6 {
-  from0[A : Cast, B, C, D, E, F](A) -> Self[A, B, C, D, E, F]
-  from1[A, B : Cast, C, D, E, F](B) -> Self[A, B, C, D, E, F]
-  from2[A, B, C : Cast, D, E, F](C) -> Self[A, B, C, D, E, F]
-  from3[A, B, C, D : Cast, E, F](D) -> Self[A, B, C, D, E, F]
-  from4[A, B, C, D, E : Cast, F](E) -> Self[A, B, C, D, E, F]
-  from5[A, B, C, D, E, F : Cast](F) -> Self[A, B, C, D, E, F]
-  to0[A : Cast, B, C, D, E, F](Self[A, B, C, D, E, F]) -> A?
-  to1[A, B : Cast, C, D, E, F](Self[A, B, C, D, E, F]) -> B?
-  to2[A, B, C : Cast, D, E, F](Self[A, B, C, D, E, F]) -> C?
-  to3[A, B, C, D : Cast, E, F](Self[A, B, C, D, E, F]) -> D?
-  to4[A, B, C, D, E : Cast, F](Self[A, B, C, D, E, F]) -> E?
-  to5[A, B, C, D, E, F : Cast](Self[A, B, C, D, E, F]) -> F?
-}
+fn[A : Cast, B, C, D, E, F] Union6::from0(A) -> Self[A, B, C, D, E, F]
+fn[A, B : Cast, C, D, E, F] Union6::from1(B) -> Self[A, B, C, D, E, F]
+fn[A, B, C : Cast, D, E, F] Union6::from2(C) -> Self[A, B, C, D, E, F]
+fn[A, B, C, D : Cast, E, F] Union6::from3(D) -> Self[A, B, C, D, E, F]
+fn[A, B, C, D, E : Cast, F] Union6::from4(E) -> Self[A, B, C, D, E, F]
+fn[A, B, C, D, E, F : Cast] Union6::from5(F) -> Self[A, B, C, D, E, F]
+fn[A : Cast, B, C, D, E, F] Union6::to0(Self[A, B, C, D, E, F]) -> A?
+fn[A, B : Cast, C, D, E, F] Union6::to1(Self[A, B, C, D, E, F]) -> B?
+fn[A, B, C : Cast, D, E, F] Union6::to2(Self[A, B, C, D, E, F]) -> C?
+fn[A, B, C, D : Cast, E, F] Union6::to3(Self[A, B, C, D, E, F]) -> D?
+fn[A, B, C, D, E : Cast, F] Union6::to4(Self[A, B, C, D, E, F]) -> E?
+fn[A, B, C, D, E, F : Cast] Union6::to5(Self[A, B, C, D, E, F]) -> F?
 
 type Union7[_, _, _, _, _, _, _]
-impl Union7 {
-  from0[A : Cast, B, C, D, E, F, G](A) -> Self[A, B, C, D, E, F, G]
-  from1[A, B : Cast, C, D, E, F, G](B) -> Self[A, B, C, D, E, F, G]
-  from2[A, B, C : Cast, D, E, F, G](C) -> Self[A, B, C, D, E, F, G]
-  from3[A, B, C, D : Cast, E, F, G](D) -> Self[A, B, C, D, E, F, G]
-  from4[A, B, C, D, E : Cast, F, G](E) -> Self[A, B, C, D, E, F, G]
-  from5[A, B, C, D, E, F : Cast, G](F) -> Self[A, B, C, D, E, F, G]
-  from6[A, B, C, D, E, F, G : Cast](G) -> Self[A, B, C, D, E, F, G]
-  to0[A : Cast, B, C, D, E, F, G](Self[A, B, C, D, E, F, G]) -> A?
-  to1[A, B : Cast, C, D, E, F, G](Self[A, B, C, D, E, F, G]) -> B?
-  to2[A, B, C : Cast, D, E, F, G](Self[A, B, C, D, E, F, G]) -> C?
-  to3[A, B, C, D : Cast, E, F, G](Self[A, B, C, D, E, F, G]) -> D?
-  to4[A, B, C, D, E : Cast, F, G](Self[A, B, C, D, E, F, G]) -> E?
-  to5[A, B, C, D, E, F : Cast, G](Self[A, B, C, D, E, F, G]) -> F?
-  to6[A, B, C, D, E, F, G : Cast](Self[A, B, C, D, E, F, G]) -> G?
-}
+fn[A : Cast, B, C, D, E, F, G] Union7::from0(A) -> Self[A, B, C, D, E, F, G]
+fn[A, B : Cast, C, D, E, F, G] Union7::from1(B) -> Self[A, B, C, D, E, F, G]
+fn[A, B, C : Cast, D, E, F, G] Union7::from2(C) -> Self[A, B, C, D, E, F, G]
+fn[A, B, C, D : Cast, E, F, G] Union7::from3(D) -> Self[A, B, C, D, E, F, G]
+fn[A, B, C, D, E : Cast, F, G] Union7::from4(E) -> Self[A, B, C, D, E, F, G]
+fn[A, B, C, D, E, F : Cast, G] Union7::from5(F) -> Self[A, B, C, D, E, F, G]
+fn[A, B, C, D, E, F, G : Cast] Union7::from6(G) -> Self[A, B, C, D, E, F, G]
+fn[A : Cast, B, C, D, E, F, G] Union7::to0(Self[A, B, C, D, E, F, G]) -> A?
+fn[A, B : Cast, C, D, E, F, G] Union7::to1(Self[A, B, C, D, E, F, G]) -> B?
+fn[A, B, C : Cast, D, E, F, G] Union7::to2(Self[A, B, C, D, E, F, G]) -> C?
+fn[A, B, C, D : Cast, E, F, G] Union7::to3(Self[A, B, C, D, E, F, G]) -> D?
+fn[A, B, C, D, E : Cast, F, G] Union7::to4(Self[A, B, C, D, E, F, G]) -> E?
+fn[A, B, C, D, E, F : Cast, G] Union7::to5(Self[A, B, C, D, E, F, G]) -> F?
+fn[A, B, C, D, E, F, G : Cast] Union7::to6(Self[A, B, C, D, E, F, G]) -> G?
 
 type Union8[_, _, _, _, _, _, _, _]
-impl Union8 {
-  from0[A : Cast, B, C, D, E, F, G, H](A) -> Self[A, B, C, D, E, F, G, H]
-  from1[A, B : Cast, C, D, E, F, G, H](B) -> Self[A, B, C, D, E, F, G, H]
-  from2[A, B, C : Cast, D, E, F, G, H](C) -> Self[A, B, C, D, E, F, G, H]
-  from3[A, B, C, D : Cast, E, F, G, H](D) -> Self[A, B, C, D, E, F, G, H]
-  from4[A, B, C, D, E : Cast, F, G, H](E) -> Self[A, B, C, D, E, F, G, H]
-  from5[A, B, C, D, E, F : Cast, G, H](F) -> Self[A, B, C, D, E, F, G, H]
-  from6[A, B, C, D, E, F, G : Cast, H](G) -> Self[A, B, C, D, E, F, G, H]
-  from7[A, B, C, D, E, F, G, H : Cast](H) -> Self[A, B, C, D, E, F, G, H]
-  to0[A : Cast, B, C, D, E, F, G, H](Self[A, B, C, D, E, F, G, H]) -> A?
-  to1[A, B : Cast, C, D, E, F, G, H](Self[A, B, C, D, E, F, G, H]) -> B?
-  to2[A, B, C : Cast, D, E, F, G, H](Self[A, B, C, D, E, F, G, H]) -> C?
-  to3[A, B, C, D : Cast, E, F, G, H](Self[A, B, C, D, E, F, G, H]) -> D?
-  to4[A, B, C, D, E : Cast, F, G, H](Self[A, B, C, D, E, F, G, H]) -> E?
-  to5[A, B, C, D, E, F : Cast, G, H](Self[A, B, C, D, E, F, G, H]) -> F?
-  to6[A, B, C, D, E, F, G : Cast, H](Self[A, B, C, D, E, F, G, H]) -> G?
-  to7[A, B, C, D, E, F, G, H : Cast](Self[A, B, C, D, E, F, G, H]) -> H?
-}
+fn[A : Cast, B, C, D, E, F, G, H] Union8::from0(A) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B : Cast, C, D, E, F, G, H] Union8::from1(B) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C : Cast, D, E, F, G, H] Union8::from2(C) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C, D : Cast, E, F, G, H] Union8::from3(D) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C, D, E : Cast, F, G, H] Union8::from4(E) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C, D, E, F : Cast, G, H] Union8::from5(F) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C, D, E, F, G : Cast, H] Union8::from6(G) -> Self[A, B, C, D, E, F, G, H]
+fn[A, B, C, D, E, F, G, H : Cast] Union8::from7(H) -> Self[A, B, C, D, E, F, G, H]
+fn[A : Cast, B, C, D, E, F, G, H] Union8::to0(Self[A, B, C, D, E, F, G, H]) -> A?
+fn[A, B : Cast, C, D, E, F, G, H] Union8::to1(Self[A, B, C, D, E, F, G, H]) -> B?
+fn[A, B, C : Cast, D, E, F, G, H] Union8::to2(Self[A, B, C, D, E, F, G, H]) -> C?
+fn[A, B, C, D : Cast, E, F, G, H] Union8::to3(Self[A, B, C, D, E, F, G, H]) -> D?
+fn[A, B, C, D, E : Cast, F, G, H] Union8::to4(Self[A, B, C, D, E, F, G, H]) -> E?
+fn[A, B, C, D, E, F : Cast, G, H] Union8::to5(Self[A, B, C, D, E, F, G, H]) -> F?
+fn[A, B, C, D, E, F, G : Cast, H] Union8::to6(Self[A, B, C, D, E, F, G, H]) -> G?
+fn[A, B, C, D, E, F, G, H : Cast] Union8::to7(Self[A, B, C, D, E, F, G, H]) -> H?
 
 pub extern type Value
-impl Value {
-  apply[Arg, Result](Self, Array[Arg]) -> Result
-  apply_with_index[Arg, Result](Self, Int, Array[Arg]) -> Result
-  apply_with_string[Arg, Result](Self, String, Array[Arg]) -> Result
-  apply_with_symbol[Arg, Result](Self, Symbol, Array[Arg]) -> Result
-  cast[T](Self) -> T
-  cast_from[T](T) -> Self
-  extends(Self, Self) -> Self
-  from_json(Json) -> Self!
-  from_json_string(String) -> Self!
-  get_with_index[T](Self, Int) -> T
-  get_with_string[T](Self, String) -> T
-  get_with_symbol[T](Self, Symbol) -> T
-  is_bool(Self) -> Bool
-  is_null(Self) -> Bool
-  is_number(Self) -> Bool
-  is_object(Self) -> Bool
-  is_string(Self) -> Bool
-  is_symbol(Self) -> Bool
-  is_undefined(Self) -> Bool
-  new[Arg, Result](Self, Array[Arg]) -> Result
-  new_with_index[Arg, Result](Self, Int, Array[Arg]) -> Result
-  new_with_string[Arg, Result](Self, String, Array[Arg]) -> Result
-  new_with_symbol[Arg, Result](Self, Symbol, Array[Arg]) -> Result
-  set_with_index[T](Self, Int, T) -> Unit
-  set_with_string[T](Self, String, T) -> Unit
-  set_with_symbol[T](Self, Symbol, T) -> Unit
-  to_json(Self) -> Json!
-  to_json_string(Self) -> String!
-  to_string(Self) -> String
-}
+fn[Arg, Result] Value::apply(Self, Array[Arg]) -> Result
+fn[Arg, Result] Value::apply_with_index(Self, Int, Array[Arg]) -> Result
+fn[Arg, Result] Value::apply_with_string(Self, String, Array[Arg]) -> Result
+fn[Arg, Result] Value::apply_with_symbol(Self, Symbol, Array[Arg]) -> Result
+fn[T] Value::cast(Self) -> T
+fn[T] Value::cast_from(T) -> Self
+fn Value::extends(Self, Self) -> Self
+fn Value::from_json(Json) -> Self!
+fn Value::from_json_string(String) -> Self!
+fn[T] Value::get_with_index(Self, Int) -> T
+fn[T] Value::get_with_string(Self, String) -> T
+fn[T] Value::get_with_symbol(Self, Symbol) -> T
+fn Value::is_bool(Self) -> Bool
+fn Value::is_null(Self) -> Bool
+fn Value::is_number(Self) -> Bool
+fn Value::is_object(Self) -> Bool
+fn Value::is_string(Self) -> Bool
+fn Value::is_symbol(Self) -> Bool
+fn Value::is_undefined(Self) -> Bool
+fn[Arg, Result] Value::new(Self, Array[Arg]) -> Result
+fn[Arg, Result] Value::new_with_index(Self, Int, Array[Arg]) -> Result
+fn[Arg, Result] Value::new_with_string(Self, String, Array[Arg]) -> Result
+fn[Arg, Result] Value::new_with_symbol(Self, Symbol, Array[Arg]) -> Result
+fn[T] Value::set_with_index(Self, Int, T) -> Unit
+fn[T] Value::set_with_string(Self, String, T) -> Unit
+fn[T] Value::set_with_symbol(Self, Symbol, T) -> Unit
+fn Value::to_json(Self) -> Json!
+fn Value::to_json_string(Self) -> String!
+fn Value::to_string(Self) -> String
 impl Show for Value
-impl @moonbitlang/core/json.FromJson for Value
+impl @json.FromJson for Value
 
 // Type aliases
 pub typealias AsyncOp = () -> Promise
diff --git a/src/js/null.mbt b/src/js/null.mbt
index 59b44e7..e6ae8fa 100644
--- a/src/js/null.mbt
+++ b/src/js/null.mbt
@@ -2,25 +2,25 @@
 extern type Nullable[_]
 
 ///|
-pub fn Nullable::is_null[T](self : Nullable[T]) -> Bool {
+pub fn[T] Nullable::is_null(self : Nullable[T]) -> Bool {
   Value::is_null(Value::cast_from(self))
 }
 
 ///|
-pub fn Nullable::get_exn[T](self : Nullable[T]) -> T = "%identity"
+pub fn[T] Nullable::get_exn(self : Nullable[T]) -> T = "%identity"
 
 ///|
-pub fn Nullable::to_option[T](self : Nullable[T]) -> T? {
+pub fn[T] Nullable::to_option(self : Nullable[T]) -> T? {
   guard not(Value::cast_from(self).is_null()) else { None }
   Some(self.get_exn())
 }
 
 ///|
-pub fn Nullable::null[T]() -> Nullable[T] {
+pub fn[T] Nullable::null() -> Nullable[T] {
   Value::null().cast()
 }
 
 ///|
-pub fn Nullable::from_option[T](value : T?) -> Nullable[T] {
+pub fn[T] Nullable::from_option(value : T?) -> Nullable[T] {
   value.map(Value::cast_from).or_else(Value::null).cast()
 }
diff --git a/src/js/object.mbt b/src/js/object.mbt
index 83062bc..1cc542f 100644
--- a/src/js/object.mbt
+++ b/src/js/object.mbt
@@ -23,35 +23,39 @@ pub extern "js" fn Object::extend_object(self : Object, obj : Object) -> Object
   #| (self, obj) => ({ ...self, ...obj })
 
 ///|
-pub fn Object::extend_iter[K, V](self : Object, it : Iter[(K, V)]) -> Unit {
+pub fn[K, V] Object::extend_iter(self : Object, it : Iter[(K, V)]) -> Unit {
   for p in it {
     self[p.0] = p.1
   }
 }
 
 ///|
-pub fn Object::from_iter[K, V](it : Iter[(K, V)]) -> Object {
-  Object::new()..extend_iter(it)
+pub fn[K, V] Object::from_iter(it : Iter[(K, V)]) -> Object {
+  let obj = Object::new()
+  obj..extend_iter(it)
+  obj
 }
 
 ///|
-pub fn Object::extend_iter2[K, V](self : Object, it : Iter2[K, V]) -> Unit {
+pub fn[K, V] Object::extend_iter2(self : Object, it : Iter2[K, V]) -> Unit {
   for k, v in it {
     self[k] = v
   }
 }
 
 ///|
-pub fn Object::from_iter2[K, V](it : Iter2[K, V]) -> Object {
-  Object::new()..extend_iter2(it)
+pub fn[K, V] Object::from_iter2(it : Iter2[K, V]) -> Object {
+  let obj = Object::new()
+  obj..extend_iter2(it)
+  obj
 }
 
 ///|
-pub fn Object::op_get[K, V](self : Object, key : K) -> V {
+pub fn[K, V] Object::op_get(self : Object, key : K) -> V {
   self._.get_ffi(Value::cast_from(key)).cast()
 }
 
 ///|
-pub fn Object::op_set[K, V](self : Object, key : K, value : V) -> Unit {
+pub fn[K, V] Object::op_set(self : Object, key : K, value : V) -> Unit {
   self._.set_ffi(Value::cast_from(key), Value::cast_from(value))
 }
diff --git a/src/js/optional.mbt b/src/js/optional.mbt
index 767085d..492bddf 100644
--- a/src/js/optional.mbt
+++ b/src/js/optional.mbt
@@ -2,15 +2,15 @@
 extern type Optional[_]
 
 ///|
-pub fn Optional::is_undefined[T](self : Optional[T]) -> Bool {
+pub fn[T] Optional::is_undefined(self : Optional[T]) -> Bool {
   self |> Value::cast_from |> Value::is_undefined
 }
 
 ///|
-pub fn Optional::get_exn[T](self : Optional[T]) -> T = "%identity"
+pub fn[T] Optional::get_exn(self : Optional[T]) -> T = "%identity"
 
 ///|
-pub fn Optional::to_option[T](self : Optional[T]) -> T? {
+pub fn[T] Optional::to_option(self : Optional[T]) -> T? {
   if Value::cast_from(self).is_undefined() {
     None
   } else {
@@ -19,12 +19,12 @@ pub fn Optional::to_option[T](self : Optional[T]) -> T? {
 }
 
 ///|
-pub fn Optional::undefined[T]() -> Optional[T] {
+pub fn[T] Optional::undefined() -> Optional[T] {
   Value::undefined().cast()
 }
 
 ///|
-pub fn Optional::from_option[T](value : T?) -> Optional[T] {
+pub fn[T] Optional::from_option(value : T?) -> Optional[T] {
   match value {
     Some(v) => Value::cast_from(v).cast()
     None => Optional::undefined()
diff --git a/src/js/require.mbt b/src/js/require.mbt
index 8a4479e..fc2e7f1 100644
--- a/src/js/require.mbt
+++ b/src/js/require.mbt
@@ -4,6 +4,6 @@ extern "js" fn require_ffi(path : String) -> Value = "(path) => require(path)"
 ///|
 pub fn require(path : String, keys~ : Array[String] = []) -> Value {
   keys.fold(init=require_ffi(path), fn {
-    acc, key => get_ffi(acc, Value::cast_from(key))
+    acc, key => acc.get_ffi(Value::cast_from(key))
   })
 }
diff --git a/src/js/union.mbt b/src/js/union.mbt
index a0cd86a..9cfa941 100644
--- a/src/js/union.mbt
+++ b/src/js/union.mbt
@@ -2,22 +2,22 @@
 extern type Union2[_, _]
 
 ///|
-pub fn Union2::to0[A : Cast, B](self : Union2[A, B]) -> A? {
+pub fn[A : Cast, B] Union2::to0(self : Union2[A, B]) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union2::to1[A, B : Cast](self : Union2[A, B]) -> B? {
+pub fn[A, B : Cast] Union2::to1(self : Union2[A, B]) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union2::from0[A : Cast, B](value : A) -> Union2[A, B] {
+pub fn[A : Cast, B] Union2::from0(value : A) -> Union2[A, B] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union2::from1[A, B : Cast](value : B) -> Union2[A, B] {
+pub fn[A, B : Cast] Union2::from1(value : B) -> Union2[A, B] {
   Cast::from(value).cast()
 }
 
@@ -25,32 +25,32 @@ pub fn Union2::from1[A, B : Cast](value : B) -> Union2[A, B] {
 extern type Union3[_, _, _]
 
 ///|
-pub fn Union3::to0[A : Cast, B, C](self : Union3[A, B, C]) -> A? {
+pub fn[A : Cast, B, C] Union3::to0(self : Union3[A, B, C]) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union3::to1[A, B : Cast, C](self : Union3[A, B, C]) -> B? {
+pub fn[A, B : Cast, C] Union3::to1(self : Union3[A, B, C]) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union3::to2[A, B, C : Cast](self : Union3[A, B, C]) -> C? {
+pub fn[A, B, C : Cast] Union3::to2(self : Union3[A, B, C]) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union3::from0[A : Cast, B, C](value : A) -> Union3[A, B, C] {
+pub fn[A : Cast, B, C] Union3::from0(value : A) -> Union3[A, B, C] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union3::from1[A, B : Cast, C](value : B) -> Union3[A, B, C] {
+pub fn[A, B : Cast, C] Union3::from1(value : B) -> Union3[A, B, C] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union3::from2[A, B, C : Cast](value : C) -> Union3[A, B, C] {
+pub fn[A, B, C : Cast] Union3::from2(value : C) -> Union3[A, B, C] {
   Cast::from(value).cast()
 }
 
@@ -58,42 +58,42 @@ pub fn Union3::from2[A, B, C : Cast](value : C) -> Union3[A, B, C] {
 extern type Union4[_, _, _, _]
 
 ///|
-pub fn Union4::to0[A : Cast, B, C, D](self : Union4[A, B, C, D]) -> A? {
+pub fn[A : Cast, B, C, D] Union4::to0(self : Union4[A, B, C, D]) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union4::to1[A, B : Cast, C, D](self : Union4[A, B, C, D]) -> B? {
+pub fn[A, B : Cast, C, D] Union4::to1(self : Union4[A, B, C, D]) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union4::to2[A, B, C : Cast, D](self : Union4[A, B, C, D]) -> C? {
+pub fn[A, B, C : Cast, D] Union4::to2(self : Union4[A, B, C, D]) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union4::to3[A, B, C, D : Cast](self : Union4[A, B, C, D]) -> D? {
+pub fn[A, B, C, D : Cast] Union4::to3(self : Union4[A, B, C, D]) -> D? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union4::from0[A : Cast, B, C, D](value : A) -> Union4[A, B, C, D] {
+pub fn[A : Cast, B, C, D] Union4::from0(value : A) -> Union4[A, B, C, D] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union4::from1[A, B : Cast, C, D](value : B) -> Union4[A, B, C, D] {
+pub fn[A, B : Cast, C, D] Union4::from1(value : B) -> Union4[A, B, C, D] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union4::from2[A, B, C : Cast, D](value : C) -> Union4[A, B, C, D] {
+pub fn[A, B, C : Cast, D] Union4::from2(value : C) -> Union4[A, B, C, D] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union4::from3[A, B, C, D : Cast](value : D) -> Union4[A, B, C, D] {
+pub fn[A, B, C, D : Cast] Union4::from3(value : D) -> Union4[A, B, C, D] {
   Cast::from(value).cast()
 }
 
@@ -101,52 +101,52 @@ pub fn Union4::from3[A, B, C, D : Cast](value : D) -> Union4[A, B, C, D] {
 extern type Union5[_, _, _, _, _]
 
 ///|
-pub fn Union5::to0[A : Cast, B, C, D, E](self : Union5[A, B, C, D, E]) -> A? {
+pub fn[A : Cast, B, C, D, E] Union5::to0(self : Union5[A, B, C, D, E]) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union5::to1[A, B : Cast, C, D, E](self : Union5[A, B, C, D, E]) -> B? {
+pub fn[A, B : Cast, C, D, E] Union5::to1(self : Union5[A, B, C, D, E]) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union5::to2[A, B, C : Cast, D, E](self : Union5[A, B, C, D, E]) -> C? {
+pub fn[A, B, C : Cast, D, E] Union5::to2(self : Union5[A, B, C, D, E]) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union5::to3[A, B, C, D : Cast, E](self : Union5[A, B, C, D, E]) -> D? {
+pub fn[A, B, C, D : Cast, E] Union5::to3(self : Union5[A, B, C, D, E]) -> D? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union5::to4[A, B, C, D, E : Cast](self : Union5[A, B, C, D, E]) -> E? {
+pub fn[A, B, C, D, E : Cast] Union5::to4(self : Union5[A, B, C, D, E]) -> E? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union5::from0[A : Cast, B, C, D, E](value : A) -> Union5[A, B, C, D, E] {
+pub fn[A : Cast, B, C, D, E] Union5::from0(value : A) -> Union5[A, B, C, D, E] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union5::from1[A, B : Cast, C, D, E](value : B) -> Union5[A, B, C, D, E] {
+pub fn[A, B : Cast, C, D, E] Union5::from1(value : B) -> Union5[A, B, C, D, E] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union5::from2[A, B, C : Cast, D, E](value : C) -> Union5[A, B, C, D, E] {
+pub fn[A, B, C : Cast, D, E] Union5::from2(value : C) -> Union5[A, B, C, D, E] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union5::from3[A, B, C, D : Cast, E](value : D) -> Union5[A, B, C, D, E] {
+pub fn[A, B, C, D : Cast, E] Union5::from3(value : D) -> Union5[A, B, C, D, E] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union5::from4[A, B, C, D, E : Cast](value : E) -> Union5[A, B, C, D, E] {
+pub fn[A, B, C, D, E : Cast] Union5::from4(value : E) -> Union5[A, B, C, D, E] {
   Cast::from(value).cast()
 }
 
@@ -154,84 +154,84 @@ pub fn Union5::from4[A, B, C, D, E : Cast](value : E) -> Union5[A, B, C, D, E] {
 extern type Union6[_, _, _, _, _, _]
 
 ///|
-pub fn Union6::to0[A : Cast, B, C, D, E, F](
+pub fn[A : Cast, B, C, D, E, F] Union6::to0(
   self : Union6[A, B, C, D, E, F]
 ) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::to1[A, B : Cast, C, D, E, F](
+pub fn[A, B : Cast, C, D, E, F] Union6::to1(
   self : Union6[A, B, C, D, E, F]
 ) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::to2[A, B, C : Cast, D, E, F](
+pub fn[A, B, C : Cast, D, E, F] Union6::to2(
   self : Union6[A, B, C, D, E, F]
 ) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::to3[A, B, C, D : Cast, E, F](
+pub fn[A, B, C, D : Cast, E, F] Union6::to3(
   self : Union6[A, B, C, D, E, F]
 ) -> D? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::to4[A, B, C, D, E : Cast, F](
+pub fn[A, B, C, D, E : Cast, F] Union6::to4(
   self : Union6[A, B, C, D, E, F]
 ) -> E? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::to5[A, B, C, D, E, F : Cast](
+pub fn[A, B, C, D, E, F : Cast] Union6::to5(
   self : Union6[A, B, C, D, E, F]
 ) -> F? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union6::from0[A : Cast, B, C, D, E, F](
+pub fn[A : Cast, B, C, D, E, F] Union6::from0(
   value : A
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union6::from1[A, B : Cast, C, D, E, F](
+pub fn[A, B : Cast, C, D, E, F] Union6::from1(
   value : B
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union6::from2[A, B, C : Cast, D, E, F](
+pub fn[A, B, C : Cast, D, E, F] Union6::from2(
   value : C
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union6::from3[A, B, C, D : Cast, E, F](
+pub fn[A, B, C, D : Cast, E, F] Union6::from3(
   value : D
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union6::from4[A, B, C, D, E : Cast, F](
+pub fn[A, B, C, D, E : Cast, F] Union6::from4(
   value : E
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union6::from5[A, B, C, D, E, F : Cast](
+pub fn[A, B, C, D, E, F : Cast] Union6::from5(
   value : F
 ) -> Union6[A, B, C, D, E, F] {
   Cast::from(value).cast()
@@ -241,98 +241,98 @@ pub fn Union6::from5[A, B, C, D, E, F : Cast](
 extern type Union7[_, _, _, _, _, _, _]
 
 ///|
-pub fn Union7::to0[A : Cast, B, C, D, E, F, G](
+pub fn[A : Cast, B, C, D, E, F, G] Union7::to0(
   self : Union7[A, B, C, D, E, F, G]
 ) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to1[A, B : Cast, C, D, E, F, G](
+pub fn[A, B : Cast, C, D, E, F, G] Union7::to1(
   self : Union7[A, B, C, D, E, F, G]
 ) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to2[A, B, C : Cast, D, E, F, G](
+pub fn[A, B, C : Cast, D, E, F, G] Union7::to2(
   self : Union7[A, B, C, D, E, F, G]
 ) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to3[A, B, C, D : Cast, E, F, G](
+pub fn[A, B, C, D : Cast, E, F, G] Union7::to3(
   self : Union7[A, B, C, D, E, F, G]
 ) -> D? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to4[A, B, C, D, E : Cast, F, G](
+pub fn[A, B, C, D, E : Cast, F, G] Union7::to4(
   self : Union7[A, B, C, D, E, F, G]
 ) -> E? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to5[A, B, C, D, E, F : Cast, G](
+pub fn[A, B, C, D, E, F : Cast, G] Union7::to5(
   self : Union7[A, B, C, D, E, F, G]
 ) -> F? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::to6[A, B, C, D, E, F, G : Cast](
+pub fn[A, B, C, D, E, F, G : Cast] Union7::to6(
   self : Union7[A, B, C, D, E, F, G]
 ) -> G? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union7::from0[A : Cast, B, C, D, E, F, G](
+pub fn[A : Cast, B, C, D, E, F, G] Union7::from0(
   value : A
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from1[A, B : Cast, C, D, E, F, G](
+pub fn[A, B : Cast, C, D, E, F, G] Union7::from1(
   value : B
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from2[A, B, C : Cast, D, E, F, G](
+pub fn[A, B, C : Cast, D, E, F, G] Union7::from2(
   value : C
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from3[A, B, C, D : Cast, E, F, G](
+pub fn[A, B, C, D : Cast, E, F, G] Union7::from3(
   value : D
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from4[A, B, C, D, E : Cast, F, G](
+pub fn[A, B, C, D, E : Cast, F, G] Union7::from4(
   value : E
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from5[A, B, C, D, E, F : Cast, G](
+pub fn[A, B, C, D, E, F : Cast, G] Union7::from5(
   value : F
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union7::from6[A, B, C, D, E, F, G : Cast](
+pub fn[A, B, C, D, E, F, G : Cast] Union7::from6(
   value : G
 ) -> Union7[A, B, C, D, E, F, G] {
   Cast::from(value).cast()
@@ -342,112 +342,112 @@ pub fn Union7::from6[A, B, C, D, E, F, G : Cast](
 extern type Union8[_, _, _, _, _, _, _, _]
 
 ///|
-pub fn Union8::to0[A : Cast, B, C, D, E, F, G, H](
+pub fn[A : Cast, B, C, D, E, F, G, H] Union8::to0(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> A? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to1[A, B : Cast, C, D, E, F, G, H](
+pub fn[A, B : Cast, C, D, E, F, G, H] Union8::to1(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> B? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to2[A, B, C : Cast, D, E, F, G, H](
+pub fn[A, B, C : Cast, D, E, F, G, H] Union8::to2(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> C? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to3[A, B, C, D : Cast, E, F, G, H](
+pub fn[A, B, C, D : Cast, E, F, G, H] Union8::to3(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> D? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to4[A, B, C, D, E : Cast, F, G, H](
+pub fn[A, B, C, D, E : Cast, F, G, H] Union8::to4(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> E? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to5[A, B, C, D, E, F : Cast, G, H](
+pub fn[A, B, C, D, E, F : Cast, G, H] Union8::to5(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> F? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to6[A, B, C, D, E, F, G : Cast, H](
+pub fn[A, B, C, D, E, F, G : Cast, H] Union8::to6(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> G? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::to7[A, B, C, D, E, F, G, H : Cast](
+pub fn[A, B, C, D, E, F, G, H : Cast] Union8::to7(
   self : Union8[A, B, C, D, E, F, G, H]
 ) -> H? {
   Cast::into(Value::cast_from(self))
 }
 
 ///|
-pub fn Union8::from0[A : Cast, B, C, D, E, F, G, H](
+pub fn[A : Cast, B, C, D, E, F, G, H] Union8::from0(
   value : A
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from1[A, B : Cast, C, D, E, F, G, H](
+pub fn[A, B : Cast, C, D, E, F, G, H] Union8::from1(
   value : B
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from2[A, B, C : Cast, D, E, F, G, H](
+pub fn[A, B, C : Cast, D, E, F, G, H] Union8::from2(
   value : C
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from3[A, B, C, D : Cast, E, F, G, H](
+pub fn[A, B, C, D : Cast, E, F, G, H] Union8::from3(
   value : D
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from4[A, B, C, D, E : Cast, F, G, H](
+pub fn[A, B, C, D, E : Cast, F, G, H] Union8::from4(
   value : E
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from5[A, B, C, D, E, F : Cast, G, H](
+pub fn[A, B, C, D, E, F : Cast, G, H] Union8::from5(
   value : F
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from6[A, B, C, D, E, F, G : Cast, H](
+pub fn[A, B, C, D, E, F, G : Cast, H] Union8::from6(
   value : G
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
 }
 
 ///|
-pub fn Union8::from7[A, B, C, D, E, F, G, H : Cast](
+pub fn[A, B, C, D, E, F, G, H : Cast] Union8::from7(
   value : H
 ) -> Union8[A, B, C, D, E, F, G, H] {
   Cast::from(value).cast()
diff --git a/src/js/value.mbt b/src/js/value.mbt
index 244eeaa..66c1edf 100644
--- a/src/js/value.mbt
+++ b/src/js/value.mbt
@@ -2,10 +2,10 @@
 pub extern type Value
 
 ///|
-pub fn Value::cast_from[T](value : T) -> Value = "%identity"
+pub fn[T] Value::cast_from(value : T) -> Value = "%identity"
 
 ///|
-pub fn Value::cast[T](self : Value) -> T = "%identity"
+pub fn[T] Value::cast(self : Value) -> T = "%identity"
 
 ///|
 pub extern "js" fn Value::to_string(self : Value) -> String = "(self) => self.toString()"
@@ -19,44 +19,44 @@ pub impl Show for Value with output(self, logger) {
 pub let globalThis : Value = get_globalThis()
 
 ///|
-pub fn get_with_string[T](self : Value, key : String) -> T {
+pub fn[T] get_with_string(self : Value, key : String) -> T {
   self.get_ffi(Value::cast_from(key)).cast()
 }
 
 ///|
-pub fn get_with_symbol[T](self : Value, key : Symbol) -> T {
+pub fn[T] get_with_symbol(self : Value, key : Symbol) -> T {
   self.get_ffi(Value::cast_from(key)).cast()
 }
 
 ///|
-pub fn get_with_index[T](self : Value, index : Int) -> T {
+pub fn[T] get_with_index(self : Value, index : Int) -> T {
   self.get_ffi(Value::cast_from(index)).cast()
 }
 
 ///|
-pub fn set_with_string[T](self : Value, key : String, value : T) -> Unit {
+pub fn[T] set_with_string(self : Value, key : String, value : T) -> Unit {
   self.set_ffi(Value::cast_from(key), Value::cast_from(value))
 }
 
 ///|
-pub fn set_with_symbol[T](self : Value, key : Symbol, value : T) -> Unit {
+pub fn[T] set_with_symbol(self : Value, key : Symbol, value : T) -> Unit {
   self.set_ffi(Value::cast_from(key), Value::cast_from(value))
 }
 
 ///|
-pub fn set_with_index[T](self : Value, index : Int, value : T) -> Unit {
+pub fn[T] set_with_index(self : Value, index : Int, value : T) -> Unit {
   self.set_ffi(Value::cast_from(index), Value::cast_from(value))
 }
 
 ///|
 /// `self(...args)`
-pub fn Value::apply[Arg, Result](self : Value, args : Array[Arg]) -> Result {
+pub fn[Arg, Result] Value::apply(self : Value, args : Array[Arg]) -> Result {
   self.apply_self_ffi(Value::cast_from(args)).cast()
 }
 
 ///|
 /// `self[key](...args)`
-pub fn Value::apply_with_string[Arg, Result](
+pub fn[Arg, Result] Value::apply_with_string(
   self : Value,
   key : String,
   args : Array[Arg]
@@ -66,7 +66,7 @@ pub fn Value::apply_with_string[Arg, Result](
 
 ///|
 /// `self[key](...args)`
-pub fn Value::apply_with_symbol[Arg, Result](
+pub fn[Arg, Result] Value::apply_with_symbol(
   self : Value,
   key : Symbol,
   args : Array[Arg]
@@ -76,7 +76,7 @@ pub fn Value::apply_with_symbol[Arg, Result](
 
 ///|
 /// `self[index](...args)`
-pub fn Value::apply_with_index[Arg, Result](
+pub fn[Arg, Result] Value::apply_with_index(
   self : Value,
   index : Int,
   args : Array[Arg]
@@ -86,13 +86,13 @@ pub fn Value::apply_with_index[Arg, Result](
 
 ///|
 /// `new self(...args)`
-pub fn Value::new[Arg, Result](self : Value, args : Array[Arg]) -> Result {
+pub fn[Arg, Result] Value::new(self : Value, args : Array[Arg]) -> Result {
   self.new_self_ffi(Value::cast_from(args)).cast()
 }
 
 ///|
 /// `new self[key](...args)`
-pub fn Value::new_with_string[Arg, Result](
+pub fn[Arg, Result] Value::new_with_string(
   self : Value,
   key : String,
   args : Array[Arg]
@@ -102,7 +102,7 @@ pub fn Value::new_with_string[Arg, Result](
 
 ///|
 /// `new self[key](...args)`
-pub fn Value::new_with_symbol[Arg, Result](
+pub fn[Arg, Result] Value::new_with_symbol(
   self : Value,
   key : Symbol,
   args : Array[Arg]
@@ -112,7 +112,7 @@ pub fn Value::new_with_symbol[Arg, Result](
 
 ///|
 /// `new self[index](...args)`
-pub fn Value::new_with_index[Arg, Result](
+pub fn[Arg, Result] Value::new_with_index(
   self : Value,
   index : Int,
   args : Array[Arg]

From 3d132a8a5fcb5cf74df98421304de0e33d99933a Mon Sep 17 00:00:00 2001
From: rami3l <rami3l@outlook.com>
Date: Mon, 9 Jun 2025 15:03:23 +0800
Subject: [PATCH 2/4] feat(async)!: remove deprecated APIs

---
 src/js/async_deprecated.mbt | 28 ----------------------------
 src/js/js.mbti              |  9 ---------
 2 files changed, 37 deletions(-)
 delete mode 100644 src/js/async_deprecated.mbt

diff --git a/src/js/async_deprecated.mbt b/src/js/async_deprecated.mbt
deleted file mode 100644
index c6cf429..0000000
--- a/src/js/async_deprecated.mbt
+++ /dev/null
@@ -1,28 +0,0 @@
-///|
-#deprecated("use Promise directly instead")
-pub typealias AsyncOp = () -> Promise
-
-///|
-extern "js" fn async_wrap_ffi(
-  op : AsyncOp,
-  on_ok : (Value) -> Unit,
-  on_err : (Value) -> Unit
-) -> Unit = "(op, on_ok, on_err) => op().then((t) => on_ok(t), (e) => on_err(e))"
-
-///|
-#deprecated("use Promise::wait instead")
-pub async fn async_wrap(op : AsyncOp) -> Value! {
-  suspend!(fn(k, ke) { async_wrap_ffi(op, k, fn(e) { ke(Error_(e)) }) })
-}
-
-///|
-#deprecated("use Promise::new instead")
-pub fn[T] async_unwrap(op : async () -> T!) -> Promise {
-  Promise::new_ffi(fn() { Value::cast_from(op!()) })
-}
-
-///|
-#deprecated("use Promise::unsafe_new instead")
-pub fn[T] Promise::new(op : async () -> T!) -> Promise {
-  Promise::unsafe_new(op)
-}
diff --git a/src/js/js.mbti b/src/js/js.mbti
index a3509d3..618c059 100644
--- a/src/js/js.mbti
+++ b/src/js/js.mbti
@@ -13,12 +13,6 @@ fn async_run(() -> Unit) -> Unit
 
 fn async_test(() -> Unit!) -> Unit
 
-#deprecated
-fn[T] async_unwrap(() -> T!) -> Promise
-
-#deprecated
-async fn async_wrap(() -> Promise) -> Value!
-
 fn extends(Value, Value) -> Value
 
 fn[T] get_with_index(Value, Int) -> T
@@ -92,8 +86,6 @@ fn[T] Optional::undefined() -> Self[T]
 
 pub extern type Promise
 fn Promise::all(Array[Self]) -> Self
-#deprecated
-fn[T] Promise::new(() -> T!) -> Self
 fn[T] Promise::unsafe_new(() -> T!) -> Self
 async fn Promise::wait(Self) -> Value!
 
@@ -221,7 +213,6 @@ impl Show for Value
 impl @json.FromJson for Value
 
 // Type aliases
-pub typealias AsyncOp = () -> Promise
 
 // Traits
 pub(open) trait Cast {

From 9859cfcdf05a3fc2d8afd5ba1e50ef7fe1727dec Mon Sep 17 00:00:00 2001
From: rami3l <rami3l@outlook.com>
Date: Mon, 9 Jun 2025 15:03:26 +0800
Subject: [PATCH 3/4] chore: bump version to 0.3.0

---
 moon.mod.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/moon.mod.json b/moon.mod.json
index 28fe7c7..41ef90e 100644
--- a/moon.mod.json
+++ b/moon.mod.json
@@ -1,6 +1,6 @@
 {
   "name": "rami3l/js-ffi",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "readme": "README.md",
   "repository": "",
   "license": "Apache-2.0",

From fea85eac8c8ff291fd9b96d7bc2b3afa8d04d7d7 Mon Sep 17 00:00:00 2001
From: rami3l <rami3l@outlook.com>
Date: Mon, 9 Jun 2025 15:03:26 +0800
Subject: [PATCH 4/4] ci: use `stable` toolchain

---
 .github/workflows/check.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 66893d2..c46a06e 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -29,12 +29,12 @@ jobs:
       - name: install
         if: ${{ matrix.os.name != 'windows-latest' }}
         run: |
-          curl -fsSL https://cli.moonbitlang.com/install/unix.sh | bash -s bleeding
+          curl -fsSL https://cli.moonbitlang.com/install/unix.sh | bash -s # bleeding
           echo "$HOME/.moon/bin" >> $GITHUB_PATH
 
       - name: install on windows
-        env:
-          MOONBIT_INSTALL_VERSION: bleeding
+        # env:
+        #   MOONBIT_INSTALL_VERSION: bleeding
         if: ${{ matrix.os.name == 'windows-latest' }}
         run: |
           Set-ExecutionPolicy RemoteSigned -Scope CurrentUser; irm https://cli.moonbitlang.com/install/powershell.ps1 | iex