moonbitlang · bobzhang · May 22, 2026 · May 22, 2026
diff --git a/examples/http_file_server/main.mbt b/examples/http_file_server/main.mbt
@@ -122,7 +122,7 @@ let page_for_404 : Bytes = b"<html><head></head><body>Page Not Found</body></htm
 async fn serve_404(conn : @http.ServerConnection) -> Unit {
   conn
   ..send_response(404, "NotFound", extra_headers={ "Content-Type": "text/html" })
-  ..write(page_for_404)
+  ..write_data(page_for_404)
   .end_response()
 }
 

diff --git a/examples/tcp_ping_pong/main.mbt b/examples/tcp_ping_pong/main.mbt
@@ -26,7 +26,7 @@ async fn server_main(server : @socket.TcpServer, println : Printer) -> Unit {
       @async.sleep(10)
       println("server received: \{@utf8.decode(msg)}")
       let reply = "pong"
-      conn.write(reply)
+      conn.write_data(reply)
       println("server sent: \{reply}")
       if msg == b"exit" {
         println("server initiate terminate")
@@ -58,7 +58,7 @@ async fn client(
   // with server side "received connection" message
   @async.sleep(10)
   println("client \{id}: connection established")
-  conn.write(msg)
+  conn.write_data(msg)
   println("client \{id} sent: \{msg}")
   if conn.read_some() is Some(msg) {
     @async.sleep(10)

diff --git a/examples/tcp_server_benchmark/main.mbt b/examples/tcp_server_benchmark/main.mbt
@@ -43,7 +43,7 @@ async fn client(
               if send_count == 0 {
                 before = @async.now()
               }
-              conn.write(data)
+              conn.write_data(data)
               send_count += data.length().to_int64()
             }
             conn_group.spawn_loop(no_wait=true) <| () => {

diff --git a/src/fs/README.mbt.md b/src/fs/README.mbt.md
@@ -46,7 +46,7 @@ async test "open file for writing" {
   let test_file = "_build/test_open_write.txt"
   let file = @fs.open(test_file, mode=WriteOnly, create_mode=CreateOrTruncate)
   defer file.close()
-  file.write(b"Hello, World!")
+  file.write_data(b"Hello, World!")
   @fs.remove(test_file)
 }
 
@@ -59,7 +59,7 @@ async test "open with append mode" {
 
   // Append to existing file
   let file = @fs.open(test_file, mode=WriteOnly, append=true)
-  file.write(b"Second line\n")
+  file.write_data(b"Second line\n")
   file.close()
   let content = @fs.read_file(test_file).text()
   @fs.remove(test_file)
@@ -75,7 +75,7 @@ The `create` function is a convenience wrapper for creating new files:
 async test "create new file" {
   let test_file = "_build/test_create.txt"
   let file = @fs.create(test_file)
-  file.write(b"New file content")
+  file.write_data(b"New file content")
   file.close()
   let exists = @fs.exists(test_file)
   @fs.remove(test_file)
@@ -173,8 +173,8 @@ async test "write with sync modes" {
 async test "write using File methods" {
   let test_file = "_build/test_file_write.txt"
   let file = @fs.create(test_file)
-  file.write(b"Line 1\n")
-  file.write(b"Line 2\n")
+  file.write_data(b"Line 1\n")
+  file.write_data(b"Line 2\n")
   file.close()
   let content = @fs.read_file(test_file).text()
   @fs.remove(test_file)
@@ -227,7 +227,7 @@ async test "write at specific position" {
   {
     let file = @fs.open(test_file, mode=WriteOnly, create_mode=CreateOrTruncate)
     defer file.close()
-    file.write("abcdef")
+    file.write_data("abcdef")
     file.write_at(b"CD", position=2)
   }
 

diff --git a/src/fs/create_test.mbt b/src/fs/create_test.mbt
@@ -18,7 +18,7 @@ async test "basic create" {
   {
     let w = @fs.create(path, sync=Full)
     defer w.close()
-    w.write(b"abcd\n")
+    w.write_data(b"abcd\n")
   }
   let result = {
     let r = @fs.open(path, mode=ReadOnly)
@@ -47,7 +47,7 @@ async test "create or append" {
       append=true,
     )
     defer w.close()
-    w.write(data)
+    w.write_data(data)
   }
 
   add_data(b"abcd")
@@ -81,7 +81,7 @@ async test "create_mode test" {
       let file = @fs.create(path, allow_existing=false)
       defer file.close()
       group.add_defer(() => @fs.remove(path))
-      file.write("abcd")
+      file.write_data("abcd")
     }
     inspect(@fs.read_file(path).text(), content="abcd")
     assert_true((try? @fs.create(path, allow_existing=false)) is Err(_))
@@ -91,25 +91,25 @@ async test "create_mode test" {
     {
       let file = @fs.open(path, mode=WriteOnly, create_mode=OpenExisting)
       defer file.close()
-      file.write("AB")
+      file.write_data("AB")
     }
     inspect(@fs.read_file(path).text(), content="ABcd")
     {
       let file = @fs.open(path, mode=WriteOnly, create_mode=OpenOrCreate)
       defer file.close()
-      file.write("XY")
+      file.write_data("XY")
     }
     inspect(@fs.read_file(path).text(), content="XYcd")
     {
       let file = @fs.open(path, mode=WriteOnly, create_mode=CreateOrTruncate)
       defer file.close()
-      file.write("12")
+      file.write_data("12")
     }
     inspect(@fs.read_file(path).text(), content="12")
     {
       let file = @fs.open(path, mode=WriteOnly, create_mode=TruncateExisting)
       defer file.close()
-      file.write("34")
+      file.write_data("34")
     }
     inspect(@fs.read_file(path).text(), content="34")
   }

diff --git a/src/fs/eof_test.mbt b/src/fs/eof_test.mbt
@@ -19,7 +19,7 @@ async test "read EOF" {
   {
     let w = @fs.create(path, permission=0o644, sync=Full)
     defer w.close()
-    w.write(b"abcd")
+    w.write_data(b"abcd")
   }
   let n = {
     let r = @fs.open(path, mode=ReadOnly)

diff --git a/src/fs/file.mbt b/src/fs/file.mbt
@@ -490,5 +490,5 @@ pub async fn write_file(
     permission~,
   )
   defer file.close()
-  file.write(content.binary())
+  file.write_data(content.binary())
 }
diff --git a/src/fs/named_pipe_test.mbt b/src/fs/named_pipe_test.mbt
@@ -76,9 +76,9 @@ async test "named fifo" {
     group.spawn_bg() <| () => {
       let w = @fs.open(path, mode=WriteOnly)
       defer w.close()
-      w.write("abcd\n")
+      w.write_data("abcd\n")
       @async.sleep(500)
-      w.write("efgh")
+      w.write_data("efgh")
     }
   }
 }

diff --git a/src/fs/random_access_test.mbt b/src/fs/random_access_test.mbt
@@ -25,7 +25,7 @@ async test "write_at" {
     defer w.close()
     w.write_at(b"56", position=w.size() - 2)
     w.write_at(b"34", position=2)
-    w.write("12") // still write from the start
+    w.write_data("12") // still write from the start
   }
   // read content
   {

diff --git a/src/fs/rename_test.mbt b/src/fs/rename_test.mbt
@@ -23,7 +23,7 @@ async test "rename basic" {
     sync=Full,
   )
   defer file.close()
-  file.write("abcd")
+  file.write_data("abcd")
   inspect(@fs.read_file(old_path).text(), content="abcd")
   @fs.rename(old_path, new_path)
   inspect(@fs.read_file(new_path).text(), content="abcd")
@@ -47,7 +47,7 @@ async test "rename replace" {
   defer old_file.close()
   let new_file = @fs.open(new_path, mode=ReadOnly, create_mode=OpenExisting)
   defer new_file.close()
-  old_file.write("abcd")
+  old_file.write_data("abcd")
   inspect(@fs.read_file(old_path).text(), content="abcd")
   inspect(@fs.read_file(new_path).text(), content="xyzw")
   assert_true((try? @fs.rename(old_path, new_path, replace=false)) is Err(_))

diff --git a/src/gzip/gzip_test.mbt b/src/gzip/gzip_test.mbt
@@ -22,7 +22,7 @@ async fn node_gzip(mode : String, input : Bytes) -> Bytes {
     })
     group.spawn_bg() <| () => {
       defer we_write.close()
-      we_write.write(input)
+      we_write.write_data(input)
     }
     let (code, stdout, stderr) = runner.wait()
     assert_eq(code, 0)
@@ -38,7 +38,7 @@ async fn encode_with_moonbit(input : Bytes) -> Bytes {
   @async.with_task_group() <| group => {
     group.spawn_bg() <| () => {
       defer w.close()
-      @gzip.Encoder(w)..write(input).end()
+      @gzip.Encoder(w)..write_data(input).end()
     }
     defer r.close()
     r.read_all().binary()
@@ -52,7 +52,7 @@ async fn decode_with_moonbit(input : Bytes) -> Bytes {
   @async.with_task_group() <| group => {
     group.spawn_bg() <| () => {
       defer w.close()
-      w.write(input)
+      w.write_data(input)
     }
     defer r.close()
     @gzip.Decoder(r).read_all().binary()
@@ -82,7 +82,7 @@ async test "encode decode roundtrip" {
         operating_system=b'\x03',
       )
       for chunk in source_chunks {
-        encoder.write(chunk)
+        encoder.write_data(chunk)
         @async.sleep(10)
       }
       encoder.end()
@@ -102,7 +102,7 @@ async test "encoder uses valid blocks across large writes" {
     root.spawn_bg() <| () => {
       defer compressed_w.close()
       let encoder = @gzip.Encoder(compressed_w)
-      encoder.write(payload)
+      encoder.write_data(payload)
       encoder.end()
     }
 
@@ -123,11 +123,11 @@ async test "encoder emits output when flushed" {
       let encoder = @gzip.Encoder(w)
       log.push("encoder ready")
       log.push("write plain ab")
-      encoder.write("ab")
+      encoder.write_data("ab")
       encoder.flush()
       @async.sleep(60)
       log.push("write plain cd")
-      encoder.write("cd")
+      encoder.write_data("cd")
       encoder.flush()
       @async.sleep(60)
       log.push("end")
@@ -153,20 +153,20 @@ async test "decoder yields plain chunks lazily across delayed chunks" {
     let (compressed_r, compressed_w) = @io.pipe()
     root.spawn_bg() <| () => {
       defer compressed_w.close()
-      compressed_w.write(b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff")
+      compressed_w.write_data(b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff")
       @async.sleep(20)
       log.push("write plain ab")
-      compressed_w.write(b"\x00\x02\x00\xfd\xffab")
+      compressed_w.write_data(b"\x00\x02\x00\xfd\xffab")
       @async.sleep(200)
       log.push("write plain cd")
-      compressed_w.write(b"\x00\x02\x00\xfd\xffcd")
+      compressed_w.write_data(b"\x00\x02\x00\xfd\xffcd")
       @async.sleep(200)
       log.push("write plain ef")
-      compressed_w.write(b"\x00\x02\x00\xfd\xffef")
+      compressed_w.write_data(b"\x00\x02\x00\xfd\xffef")
       @async.sleep(200)
       log.push("finish")
-      compressed_w.write(b"\x01\x00\x00\xff\xff")
-      compressed_w.write(b"\xef\x39\x8e\x4b\x06\x00\x00\x00")
+      compressed_w.write_data(b"\x01\x00\x00\xff\xff")
+      compressed_w.write_data(b"\xef\x39\x8e\x4b\x06\x00\x00\x00")
     }
     let decoder = @gzip.Decoder(compressed_r)
     match decoder.read_some(max_len=2) {
@@ -195,12 +195,12 @@ async test "decoder supports reads smaller than writer chunks" {
     let (compressed_r, compressed_w) = @io.pipe()
     root.spawn_bg() <| () => {
       defer compressed_w.close()
-      compressed_w.write(b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff")
-      compressed_w.write(b"\x00\x04\x00\xfb\xffabcd")
+      compressed_w.write_data(b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff")
+      compressed_w.write_data(b"\x00\x04\x00\xfb\xffabcd")
       @async.sleep(200)
-      compressed_w.write(b"\x00\x04\x00\xfb\xffefgh")
-      compressed_w.write(b"\x01\x00\x00\xff\xff")
-      compressed_w.write(b"\x50\x2a\xef\xae\x08\x00\x00\x00")
+      compressed_w.write_data(b"\x00\x04\x00\xfb\xffefgh")
+      compressed_w.write_data(b"\x01\x00\x00\xff\xff")
+      compressed_w.write_data(b"\x50\x2a\xef\xae\x08\x00\x00\x00")
     }
     let decoder = @gzip.Decoder(compressed_r)
     debug_inspect(

diff --git a/src/http/README.mbt.md b/src/http/README.mbt.md
@@ -81,7 +81,7 @@ Here's an example server that returns 404 to every request:
 #cfg(target="native")
 pub async fn server(listen_addr : @socket.Addr) -> Unit {
   @http.Server(listen_addr).run_forever((request, _body, conn) => {
-    conn..send_response(404, "NotFound").write("`\{request.path}` not found")
+    conn..send_response(404, "NotFound").write_data("`\{request.path}` not found")
   })
 }
 ```
diff --git a/src/http/client.mbt b/src/http/client.mbt
@@ -269,7 +269,7 @@ pub async fn Client::get(
 ) -> Response {
   self.request(Get, path, extra_headers~)
   if body is Some(body) {
-    self.write(body)
+    self.write_data(body)
   }
   self.end_request()
 }
@@ -282,7 +282,7 @@ pub async fn Client::put(
   body : &@io.Data,
   extra_headers? : Map[String, String] = {},
 ) -> Response {
-  self..request(Put, path, extra_headers~)..write(body).end_request()
+  self..request(Put, path, extra_headers~)..write_data(body).end_request()
 }
 
 ///|
@@ -293,7 +293,7 @@ pub async fn Client::post(
   body : &@io.Data,
   extra_headers? : Map[String, String] = {},
 ) -> Response {
-  self..request(Post, path, extra_headers~)..write(body).end_request()
+  self..request(Post, path, extra_headers~)..write_data(body).end_request()
 }
 
 ///|

diff --git a/src/http/client_test.mbt b/src/http/client_test.mbt
@@ -26,10 +26,10 @@ async fn test_server(group : @async.TaskGroup[Unit], log : &Logger) -> Int {
       }
       conn.send_response(200, "OK")
       log.write_string("server: sending \{meth} response part 1\n")
-      conn..write("\{meth} response part 1\n").flush()
+      conn..write_data("\{meth} response part 1\n").flush()
       @async.sleep(100)
       log.write_string("server: sending \{meth} response part 2\n")
-      conn.write("\{meth} response part 2\n")
+      conn.write_data("\{meth} response part 2\n")
     })
   }
   server.addr.port()
@@ -114,10 +114,10 @@ async test "request streaming" {
       defer client.close()
       @async.sleep(100)
       log <+ "client: sending PUT data part 1\n"
-      client..write("PUT data part 1\n").flush()
+      client..write_data("PUT data part 1\n").flush()
       @async.sleep(100)
       log <+ "client: sending PUT data part 2\n"
-      client.write("PUT data part 2\n")
+      client.write_data("PUT data part 2\n")
       let response = client.end_request()
       inspect(response.code, content="200")
       fetch_response(client)
@@ -128,10 +128,10 @@ async test "request streaming" {
       defer client.close()
       @async.sleep(100)
       log <+ "client: sending POST data part 1\n"
-      client..write("POST data part 1\n").flush()
+      client..write_data("POST data part 1\n").flush()
       @async.sleep(100)
       log <+ "client: sending POST data part 2\n"
-      client.write("POST data part 2\n")
+      client.write_data("POST data part 2\n")
       let response = client.end_request()
       inspect(response.code, content="200")
       fetch_response(client)