add @io.Data and use it for convenient conversion of data format

Author: Guest0x0

examples/tcp_server_benchmark/moon.pkg.json

@@ -2,6 +2,7 @@
   "is-main": true,
   "import": [
     "moonbitlang/async",
+    "moonbitlang/async/io",
     "moonbitlang/async/socket"
   ]
 }

src/fs/create_test.mbt

@@ -23,7 +23,7 @@ async test "basic create" {
   let result = {
     let r = @fs.open(path, mode=ReadOnly)
     defer r.close()
-    @bytes_util.ascii_to_string(r.read_all())
+    r.read_all().text()
   }
   @fs.remove(path)
   inspect(
@@ -49,7 +49,7 @@ async test "create or append" {
   let result = {
     let r = @fs.open(path, mode=ReadOnly)
     defer r.close()
-    r.read_all() |> @bytes_util.ascii_to_string
+    r.read_all().text()
   }
   @fs.remove(path)
   inspect(result, content="abcdefgh")
@@ -59,7 +59,7 @@ async test "create or append" {
 async test "wrapper test" {
   let path = "fs_wrapper_test"
   @fs.write_file(path, b"abcd", create=0o644)
-  let result = @fs.read_file(path) |> @bytes_util.ascii_to_string
+  let result = @fs.read_file(path).text()
   @fs.remove(path)
   inspect(result, content="abcd")
 }

src/fs/fs.mbt

@@ -182,7 +182,7 @@ pub impl @io.Reader for File with read_all(self) {
       let size = self.size().to_int()
       let result = FixedArray::make(size, b'0')
       guard self.read(result) == size
-      result.unsafe_reinterpret_as_bytes()
+      result.unsafe_reinterpret_as_bytes() as &@io.Data
     }
     _ => @io.Reader::read_all(DummyFile(self))
   }
@@ -282,7 +282,7 @@ pub fn File::kind(self : File) -> FileKind {
 
 ///|
 /// Read the contents of the file located at `path`.
-pub async fn read_file(path : String) -> Bytes {
+pub async fn read_file(path : String) -> &@io.Data {
   let file = open(path, mode=ReadOnly)
   defer file.close()
   file.read_all()
@@ -292,7 +292,7 @@ pub async fn read_file(path : String) -> Bytes {
 /// Read the contents of a text file located at `path`.
 pub async fn read_text_file(path : String, encoding~ : @io.Encoding) -> String {
   guard encoding is UTF8
-  @encoding/utf8.decode(read_file(path))
+  read_file(path).text()
 }
 
 ///|

src/fs/pkg.generated.mbti

@@ -24,7 +24,7 @@ async fn open(String, mode~ : Mode, sync? : SyncMode, append? : Bool, create? :
 
 fn opendir(String) -> Directory raise
 
-async fn read_file(String) -> Bytes
+async fn read_file(String) -> &@io.Data
 
 async fn read_text_file(String, encoding~ : @io.Encoding) -> String
 

src/fs/read_all_test.mbt

@@ -18,7 +18,7 @@ async test "read_all basic" {
   let r = @fs.open(path, mode=ReadOnly)
   defer r.close()
   inspect(
-    r.read_all() |> @bytes_util.ascii_to_string,
+    r.read_all().text(),
     content=(
       #|
       #|                                 Apache License

src/fs/seek_test.mbt

@@ -28,7 +28,7 @@ async test "basic seek" {
     let r = @fs.open(path, mode=ReadOnly)
     defer r.close()
     inspect(r.size(), content="6")
-    inspect(@bytes_util.ascii_to_string(r.read_all()), content="abcdef")
+    inspect(r.read_all().text(), content="abcdef")
   }
   // update content
   {
@@ -48,7 +48,7 @@ async test "basic seek" {
   {
     let r = @fs.open(path, mode=ReadOnly)
     defer r.close()
-    inspect(@bytes_util.ascii_to_string(r.read_all()), content="123456")
+    inspect(r.read_all().text(), content="123456")
   }
   @fs.remove(path)
 }

src/http/client.mbt

@@ -79,13 +79,6 @@ pub impl @io.Reader for Client with read(
   self.reader.read(buf, offset~, max_len~)
 }
 
-///|
-/// Read the whole response body from a HTTP client.
-/// Must be called after `end_request`.
-pub async fn Client::read_all(self : Client) -> &Body {
-  @io.Reader::read_all(self.reader)
-}
-
 ///|
 /// Write data to the body of the request currently being sent.
 /// Must be called after `send_request`.
@@ -165,11 +158,11 @@ pub async fn Client::get(
   self : Client,
   path : String,
   extra_headers? : Map[String, String] = {},
-  body? : &Body,
+  body? : &@io.Data,
 ) -> Response {
   self.request(Get, path, extra_headers~)
   if body is Some(body) {
-    self.write(body.to_bytes())
+    self.write(body)
   }
   self.end_request()
 }
@@ -179,22 +172,19 @@ pub async fn Client::get(
 pub async fn Client::put(
   self : Client,
   path : String,
-  body : &Body,
+  body : &@io.Data,
   extra_headers? : Map[String, String] = {},
 ) -> Response {
-  self..request(Put, path, extra_headers~)..write(body.to_bytes()).end_request()
+  self..request(Put, path, extra_headers~)..write(body).end_request()
 }
 
 ///|
 /// Perform a `POST` request to the server, see `Client::request` for more details.
 pub async fn Client::post(
   self : Client,
   path : String,
-  body : &Body,
+  body : &@io.Data,
   extra_headers? : Map[String, String] = {},
 ) -> Response {
-  self
-  ..request(Post, path, extra_headers~)
-  ..write(body.to_bytes())
-  .end_request()
+  self..request(Post, path, extra_headers~)..write(body).end_request()
 }

src/http/parser_wbtest.mbt

@@ -47,7 +47,7 @@ async test "read_request basic" {
     let input = Reader::new(r)
     let request = input.read_request()
     log_request(request, log)
-    log.write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    log.write_string(input.read_all().text())
   })
   inspect(
     log.to_string(),
@@ -78,7 +78,7 @@ async test "read_request fixed body" {
     let input = Reader::new(r)
     let request = input.read_request()
     log_request(request, log)
-    log.write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    log.write_string(input.read_all().text())
   })
   inspect(
     log.to_string(),
@@ -114,7 +114,7 @@ async test "read_request chunked" {
     let input = Reader::new(r)
     let request = input.read_request()
     log_request(request, log)
-    log.write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    log.write_string(input.read_all().text())
   })
   inspect(
     log.to_string(),
@@ -215,11 +215,11 @@ async test "multiple request" {
     let request = input.read_request()
     log_request(request, log)
     log
-    ..write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    ..write_string(input.read_all().text())
     ..write_string("\n\n=========\n\n")
     let request = input.read_request()
     log_request(request, log)
-    log.write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    log.write_string(input.read_all().text())
   })
   inspect(
     log.to_string(),
@@ -260,7 +260,7 @@ async test "read_response basic" {
     let input = Reader::new(r)
     let response = input.read_response()
     log_response(response, log)
-    log.write_string(input.read_all() |> @bytes_util.ascii_to_string)
+    log.write_string(input.read_all().text())
   })
   inspect(
     log.to_string(),

src/http/pkg.generated.mbti

@@ -2,15 +2,16 @@
 package "moonbitlang/async/http"
 
 import(
+  "moonbitlang/async/io"
   "moonbitlang/async/socket"
 )
 
 // Values
-async fn get(String, headers? : Map[String, String], port? : Int, body? : &Body) -> (Response, &Body)
+async fn get(String, headers? : Map[String, String], port? : Int, body? : &@io.Data) -> (Response, &@io.Data)
 
-async fn post(String, &Body, headers? : Map[String, String], port? : Int) -> (Response, &Body)
+async fn post(String, &@io.Data, headers? : Map[String, String], port? : Int) -> (Response, &@io.Data)
 
-async fn put(String, &Body, headers? : Map[String, String], port? : Int) -> (Response, &Body)
+async fn put(String, &@io.Data, headers? : Map[String, String], port? : Int) -> (Response, &@io.Data)
 
 // Errors
 pub suberror HttpProtocolError {
@@ -32,14 +33,13 @@ fn Client::close(Self) -> Unit
 async fn Client::connect(String, headers? : Map[String, String], protocol? : Protocol, port? : Int) -> Self
 async fn Client::end_request(Self) -> Response
 async fn Client::flush(Self) -> Unit
-async fn Client::get(Self, String, extra_headers? : Map[String, String], body? : &Body) -> Response
-async fn Client::post(Self, String, &Body, extra_headers? : Map[String, String]) -> Response
-async fn Client::put(Self, String, &Body, extra_headers? : Map[String, String]) -> Response
-async fn Client::read_all(Self) -> &Body
+async fn Client::get(Self, String, extra_headers? : Map[String, String], body? : &@io.Data) -> Response
+async fn Client::post(Self, String, &@io.Data, extra_headers? : Map[String, String]) -> Response
+async fn Client::put(Self, String, &@io.Data, extra_headers? : Map[String, String]) -> Response
 async fn Client::request(Self, RequestMethod, String, extra_headers? : Map[String, String]) -> Unit
 async fn Client::skip_response_body(Self) -> Unit
-impl @moonbitlang/async/io.Reader for Client
-impl @moonbitlang/async/io.Writer for Client
+impl @io.Reader for Client
+impl @io.Writer for Client
 
 pub(all) enum Protocol {
   Http
@@ -77,22 +77,13 @@ fn ServerConnection::close(Self) -> Unit
 async fn ServerConnection::end_response(Self) -> Unit
 async fn ServerConnection::flush(Self) -> Unit
 fn ServerConnection::new(@socket.TCP, headers? : Map[String, String]) -> Self
-async fn ServerConnection::read_all(Self) -> &Body
 async fn ServerConnection::read_request(Self) -> Request
 async fn ServerConnection::send_response(Self, Int, String, extra_headers? : Map[String, String]) -> Unit
 async fn ServerConnection::skip_request_body(Self) -> Unit
-impl @moonbitlang/async/io.Reader for ServerConnection
-impl @moonbitlang/async/io.Writer for ServerConnection
-
-async fn Body::binary(&Self) -> Bytes
-async fn Body::json(&Self) -> Json
-async fn Body::text(&Self) -> String
+impl @io.Reader for ServerConnection
+impl @io.Writer for ServerConnection
 
 // Type aliases
 
 // Traits
-trait Body
-impl Body for String
-impl Body for Bytes
-impl Body for Json
 

src/http/request.mbt

@@ -37,9 +37,9 @@ async fn perform_request(
   uri : String,
   meth : RequestMethod,
   headers : Map[String, String],
-  body : &Body,
+  body : &@io.Data,
   port? : Int,
-) -> (Response, &Body) {
+) -> (Response, &@io.Data) {
   guard uri.find("://") is Some(protocol_len) else { raise InvalidFormat }
   let protocol = match uri[:protocol_len] {
     "http" => Http
@@ -63,7 +63,7 @@ async fn perform_request(
   let path = if path == "" { "/" } else { path }
   let client = Client::connect(host, headers~, protocol~, port~)
   defer client.close()
-  client..request(meth, path)..write(body.to_bytes())
+  client..request(meth, path)..write(body)
   let response = client.end_request()
   (response, client.read_all())
 }
@@ -81,29 +81,29 @@ pub async fn get(
   uri : String,
   headers? : Map[String, String] = {},
   port? : Int,
-  body? : &Body = b"",
-) -> (Response, &Body) {
+  body? : &@io.Data = b"",
+) -> (Response, &@io.Data) {
   perform_request(uri, Get, headers, body, port?)
 }
 
 ///|
 /// Similar to `get`, but performs a `PUT` request instead.
 pub async fn put(
   uri : String,
-  content : &Body,
+  content : &@io.Data,
   headers? : Map[String, String] = {},
   port? : Int,
-) -> (Response, &Body) {
+) -> (Response, &@io.Data) {
   perform_request(uri, Put, headers, content, port?)
 }
 
 ///|
 /// Similar to `get`, but performs a `POST` request instead.
 pub async fn post(
   uri : String,
-  content : &Body,
+  content : &@io.Data,
   headers? : Map[String, String] = {},
   port? : Int,
-) -> (Response, &Body) {
+) -> (Response, &@io.Data) {
   perform_request(uri, Post, headers, content, port?)
 }