@shd101wyy/yo 0.1.26 → 0.1.27

package/std/sys/advise.yo

@@ -2,35 +2,27 @@
 //!
 //! Advisory wrappers for file and memory access pattern hints.
 //! Returns 0 on success, -errno / negative platform error on failure.
-
-{
-  __yo_sync_fadvise,
-  __yo_sync_madvise
-} :: import "./externs.yo";
-
-POSIX_FADV_NORMAL     :: i32(0);
-POSIX_FADV_RANDOM     :: i32(1);
+{ __yo_sync_fadvise, __yo_sync_madvise } :: import("./externs.yo");
+POSIX_FADV_NORMAL :: i32(0);
+POSIX_FADV_RANDOM :: i32(1);
 POSIX_FADV_SEQUENTIAL :: i32(2);
-POSIX_FADV_WILLNEED   :: i32(3);
-POSIX_FADV_DONTNEED   :: i32(4);
-POSIX_FADV_NOREUSE    :: i32(5);
-
-MADV_NORMAL     :: i32(0);
-MADV_RANDOM     :: i32(1);
+POSIX_FADV_WILLNEED :: i32(3);
+POSIX_FADV_DONTNEED :: i32(4);
+POSIX_FADV_NOREUSE :: i32(5);
+MADV_NORMAL :: i32(0);
+MADV_RANDOM :: i32(1);
 MADV_SEQUENTIAL :: i32(2);
-MADV_WILLNEED   :: i32(3);
-MADV_DONTNEED   :: i32(4);
-
-fadvise :: (fn(fd: i32, offset: i64, len: i64, advice: i32) -> i32)(
+MADV_WILLNEED :: i32(3);
+MADV_DONTNEED :: i32(4);
+fadvise :: (fn(fd : i32, offset : i64, len : i64, advice : i32) -> i32)(
   __yo_sync_fadvise(fd, offset, len, advice)
 );
-
-madvise :: (fn(addr: *(u8), length: usize, advice: i32) -> i32)(
+madvise :: (fn(addr : *(u8), length : usize, advice : i32) -> i32)(
   __yo_sync_madvise(addr, length, advice)
 );
-
-export
-  fadvise, madvise,
+export(
+  fadvise,
+  madvise,
   POSIX_FADV_NORMAL,
   POSIX_FADV_RANDOM,
   POSIX_FADV_SEQUENTIAL,
@@ -42,4 +34,4 @@ export
   MADV_SEQUENTIAL,
   MADV_WILLNEED,
   MADV_DONTNEED
-;
+);

package/std/sys/bufio/buf_reader.yo

@@ -17,77 +17,69 @@
 //!   .Err(e) => println(e.to_string())
 //! );
 //! ```
-
-{ ArrayList } :: import "../../collections/array_list";
-open import "../../string";
-{ IOError } :: import "../errors";
-IO_file :: import "../file";
-{ GlobalAllocator } :: import "../../allocator";
+{ ArrayList } :: import("../../collections/array_list");
+open(import("../../string"));
+{ IOError } :: import("../errors");
+IO_file :: import("../file");
+{ GlobalAllocator } :: import("../../allocator");
 { malloc, free } :: GlobalAllocator;
-
 _DEFAULT_BUF_SIZE :: usize(4096);
 _NEWLINE :: u8(10); // '\n'
-
 BufReader :: object(
-  _fd       : i32,
-  _buf      : ArrayList(u8),
-  _pos      : usize,
-  _filled   : usize,
-  _offset   : u64,
+  _fd : i32,
+  _buf : ArrayList(u8),
+  _pos : usize,
+  _filled : usize,
+  _offset : u64,
   _capacity : usize
 );
-
-impl(BufReader,
+impl(
+  BufReader,
   // Create a buffered reader with default buffer size (4096 bytes).
-  new : (fn(fd: i32) -> Self)(
+  new : (fn(fd : i32) -> Self)(
     Self(
-      _fd: fd,
-      _buf: ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
-      _pos: usize(0),
-      _filled: usize(0),
-      _offset: u64(0),
-      _capacity: _DEFAULT_BUF_SIZE
+      _fd : fd,
+      _buf : ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
+      _pos : usize(0),
+      _filled : usize(0),
+      _offset : u64(0),
+      _capacity : _DEFAULT_BUF_SIZE
     )
   ),
-
   // Create a buffered reader with a custom buffer size.
-  with_capacity : (fn(fd: i32, capacity: usize) -> Self)(
+  with_capacity : (fn(fd : i32, capacity : usize) -> Self)(
     Self(
-      _fd: fd,
-      _buf: ArrayList(u8).with_capacity(capacity),
-      _pos: usize(0),
-      _filled: usize(0),
-      _offset: u64(0),
-      _capacity: capacity
+      _fd : fd,
+      _buf : ArrayList(u8).with_capacity(capacity),
+      _pos : usize(0),
+      _filled : usize(0),
+      _offset : u64(0),
+      _capacity : capacity
     )
   ),
-
   // Return the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     self._fd
   ),
-
   // Return the number of buffered bytes available to read without I/O.
-  buffered : (fn(self: Self) -> usize)(
-    (self._filled - self._pos)
+  buffered : (fn(self : Self) -> usize)(
+    self._filled - self._pos
   ),
-
   // Read a line from the reader (up to and including '\n').
   // Returns .None on EOF when no data is available.
   // Returns .Some(line) with the line content (without the trailing '\n').
-  read_line : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(Option(String), IOError), IO)))({
+  read_line : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(Option(String), IOError), IO)))({
     the_fd := self._fd;
     io.async((using(io : IO)) => {
       line_bytes := ArrayList(u8).new();
       found_newline := false;
       hit_eof := false;
-      (read_err : Option(IOError)) = .None;
-
-      while runtime((((!(found_newline)) && (!(hit_eof))) && read_err.is_none())), {
+      (read_err : Option(IOError)) =.None;
+      while(runtime(((!(found_newline)) && (!(hit_eof))) && read_err.is_none()), {
         cond(
           (self._pos < self._filled) => {
             scan := self._pos;
-            while runtime(((scan < self._filled) && (!(found_newline)))), {
+            while(runtime((scan < self._filled) && (!(found_newline))), {
               b := self._buf.get(scan).unwrap();
               cond(
                 (b == _NEWLINE) => {
@@ -98,7 +90,7 @@ impl(BufReader,
                 }
               );
               scan = (scan + usize(1));
-            };
+            });
             self._pos = scan;
           },
           true => {
@@ -107,7 +99,7 @@ impl(BufReader,
             cond(
               (n < i32(0)) => {
                 free(.Some(*(void)(raw_buf)));
-                read_err = .Some(IOError.from_errno((i32(0) - n)));
+                read_err =.Some(IOError.from_errno(i32(0) - n));
               },
               (n == i32(0)) => {
                 free(.Some(*(void)(raw_buf)));
@@ -117,10 +109,10 @@ impl(BufReader,
                 self._offset = (self._offset + u64(n));
                 self._buf = ArrayList(u8).with_capacity(self._capacity);
                 i := usize(0);
-                while runtime((i < usize(n))), {
+                while(runtime(i < usize(n)), {
                   self._buf.push((raw_buf &+ i).*);
                   i = (i + usize(1));
-                };
+                });
                 self._pos = usize(0);
                 self._filled = usize(n);
                 free(.Some(*(void)(raw_buf)));
@@ -128,29 +120,27 @@ impl(BufReader,
             );
           }
         );
-      };
-
-      match(read_err,
-        .Some(e) => .Err(e),
+      });
+      match(
+        read_err,
+        .Some(e) =>.Err(e),
         .None =>
           cond(
-            (hit_eof && (line_bytes.len() == usize(0))) => .Ok(.None),
-            true => .Ok(.Some(String.from_bytes(line_bytes)))
+            (hit_eof && (line_bytes.len() == usize(0))) =>.Ok(.None),
+            true =>.Ok(.Some(String.from_bytes(line_bytes)))
           )
       )
     })
   }),
-
   // Read up to `size` bytes into a provided buffer.
   // Returns the number of bytes actually read.
-  read : (fn(self: Self, buf: *(u8), size: u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
     the_fd := self._fd;
     io.async((using(io : IO)) => {
       available := (self._filled - self._pos);
-      (read_err : Option(IOError)) = .None;
+      (read_err : Option(IOError)) =.None;
       (read_n : i32) = i32(0);
       done := false;
-
       // If there's data already buffered, serve from buffer
       cond(
         (available > usize(0)) => {
@@ -159,25 +149,24 @@ impl(BufReader,
             true => usize(size)
           );
           i := usize(0);
-          while runtime((i < to_copy)), {
-            b := self._buf.get((self._pos + i)).unwrap();
+          while(runtime(i < to_copy), {
+            b := self._buf.get(self._pos + i).unwrap();
             (buf &+ i).* = b;
             i = (i + usize(1));
-          };
+          });
           self._pos = (self._pos + to_copy);
           read_n = i32(to_copy);
           done = true;
         },
         true => ()
       );
-
       // Buffer is empty and large read: bypass buffer
       cond(
         ((!(done)) && (usize(size) >= self._capacity)) => {
           n := io.await(IO_file.read(the_fd, buf, size, self._offset));
           cond(
             (n < i32(0)) => {
-              read_err = .Some(IOError.from_errno((i32(0) - n)));
+              read_err =.Some(IOError.from_errno(i32(0) - n));
             },
             true => {
               self._offset = (self._offset + u64(n));
@@ -188,7 +177,6 @@ impl(BufReader,
         },
         true => ()
       );
-
       // Buffer is empty and small read: fill buffer first
       cond(
         (!(done)) => {
@@ -197,7 +185,7 @@ impl(BufReader,
           cond(
             (n < i32(0)) => {
               free(.Some(*(void)(raw_buf)));
-              read_err = .Some(IOError.from_errno((i32(0) - n)));
+              read_err =.Some(IOError.from_errno(i32(0) - n));
             },
             (n == i32(0)) => {
               free(.Some(*(void)(raw_buf)));
@@ -207,24 +195,23 @@ impl(BufReader,
               self._offset = (self._offset + u64(n));
               self._buf = ArrayList(u8).with_capacity(self._capacity);
               i := usize(0);
-              while runtime((i < usize(n))), {
+              while(runtime(i < usize(n)), {
                 self._buf.push((raw_buf &+ i).*);
                 i = (i + usize(1));
-              };
+              });
               self._pos = usize(0);
               self._filled = usize(n);
               free(.Some(*(void)(raw_buf)));
-
               to_copy := cond(
                 (usize(n) < usize(size)) => usize(n),
                 true => usize(size)
               );
               j := usize(0);
-              while runtime((j < to_copy)), {
+              while(runtime(j < to_copy), {
                 b := self._buf.get(j).unwrap();
                 (buf &+ j).* = b;
                 j = (j + usize(1));
-              };
+              });
               self._pos = to_copy;
               read_n = i32(to_copy);
             }
@@ -232,72 +219,69 @@ impl(BufReader,
         },
         true => ()
       );
-
-      match(read_err,
-        .Some(e) => .Err(e),
-        .None => .Ok(read_n)
+      match(
+        read_err,
+        .Some(e) =>.Err(e),
+        .None =>.Ok(read_n)
       )
     })
   }),
-
   // Read all remaining data into an ArrayList of bytes.
-  read_bytes : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
+  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
     the_fd := self._fd;
     io.async((using(io : IO)) => {
       result := ArrayList(u8).new();
-
       // First drain any buffered data
       cond(
         (self._pos < self._filled) => {
           i := self._pos;
-          while runtime((i < self._filled)), {
+          while(runtime(i < self._filled), {
             result.push(self._buf.get(i).unwrap());
             i = (i + usize(1));
-          };
+          });
           self._pos = self._filled;
         },
         true => ()
       );
-
       // Then read the rest from fd
       raw_buf := *(u8)(malloc(self._capacity).unwrap());
-      (read_err : Option(IOError)) = .None;
-      while runtime(true), {
+      (read_err : Option(IOError)) =.None;
+      while(runtime(true), {
         n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
         cond(
           (n < i32(0)) => {
-            read_err = .Some(IOError.from_errno((i32(0) - n)));
+            read_err =.Some(IOError.from_errno(i32(0) - n));
             break;
           },
           (n == i32(0)) => break,
           true => {
             self._offset = (self._offset + u64(n));
             j := usize(0);
-            while runtime((j < usize(n))), {
+            while(runtime(j < usize(n)), {
               result.push((raw_buf &+ j).*);
               j = (j + usize(1));
-            };
+            });
           }
         );
-      };
+      });
       free(.Some(*(void)(raw_buf)));
-      match(read_err,
-        .Some(e) => .Err(e),
-        .None => .Ok(result)
+      match(
+        read_err,
+        .Some(e) =>.Err(e),
+        .None =>.Ok(result)
       )
     })
   }),
-
   // Read all remaining data as a String.
-  read_to_string : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
+  read_to_string : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
     io.async((using(io : IO)) => {
       bytes_result := io.await(self.read_bytes(using(io)));
-      match(bytes_result,
-        .Ok(bytes) => .Ok(String.from_bytes(bytes)),
-        .Err(e) => .Err(e)
+      match(
+        bytes_result,
+        .Ok(bytes) =>.Ok(String.from_bytes(bytes)),
+        .Err(e) =>.Err(e)
       )
     })
   )
 );
-
-export BufReader;
+export(BufReader);

package/std/sys/bufio/buf_writer.yo

@@ -12,110 +12,101 @@
 //! io.await(writer.write_string(`hello\n`, using(io)));
 //! io.await(writer.flush(using(io)));
 //! ```
-
-{ ArrayList } :: import "../../collections/array_list";
-open import "../../string";
-{ IOError } :: import "../errors";
-IO_file :: import "../file";
-{ GlobalAllocator } :: import "../../allocator";
+{ ArrayList } :: import("../../collections/array_list");
+open(import("../../string"));
+{ IOError } :: import("../errors");
+IO_file :: import("../file");
+{ GlobalAllocator } :: import("../../allocator");
 { malloc, free } :: GlobalAllocator;
-
 _DEFAULT_BUF_SIZE :: usize(4096);
-
 BufWriter :: object(
-  _fd       : i32,
-  _buf      : ArrayList(u8),
-  _offset   : u64,
+  _fd : i32,
+  _buf : ArrayList(u8),
+  _offset : u64,
   _capacity : usize
 );
-
-impl(BufWriter,
+impl(
+  BufWriter,
   // Create a buffered writer with default buffer size (4096 bytes).
-  new : (fn(fd: i32) -> Self)(
+  new : (fn(fd : i32) -> Self)(
     Self(
-      _fd: fd,
-      _buf: ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
-      _offset: u64(0),
-      _capacity: _DEFAULT_BUF_SIZE
+      _fd : fd,
+      _buf : ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
+      _offset : u64(0),
+      _capacity : _DEFAULT_BUF_SIZE
     )
   ),
-
   // Create a buffered writer with a custom buffer size.
-  with_capacity : (fn(fd: i32, capacity: usize) -> Self)(
+  with_capacity : (fn(fd : i32, capacity : usize) -> Self)(
     Self(
-      _fd: fd,
-      _buf: ArrayList(u8).with_capacity(capacity),
-      _offset: u64(0),
-      _capacity: capacity
+      _fd : fd,
+      _buf : ArrayList(u8).with_capacity(capacity),
+      _offset : u64(0),
+      _capacity : capacity
     )
   ),
-
   // Return the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     self._fd
   ),
-
   // Return the number of bytes currently buffered.
-  buffered : (fn(self: Self) -> usize)(
+  buffered : (fn(self : Self) -> usize)(
     self._buf.len()
   ),
-
   // Internal: flush the buffer contents to fd.
-  _flush_inner : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  _flush_inner : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
     the_fd := self._fd;
     io.async((using(io : IO)) => {
-      (write_err : Option(IOError)) = .None;
-
+      (write_err : Option(IOError)) =.None;
       cond(
         (self._buf.len() > usize(0)) => {
           written := usize(0);
           total := self._buf.len();
-
-          while runtime(((written < total) && write_err.is_none())), {
-            remaining := u32((total - written));
+          while(runtime((written < total) && write_err.is_none()), {
+            remaining := u32(total - written);
             buf_ptr := self._buf.ptr().unwrap();
-            n := io.await(IO_file.write(the_fd, (buf_ptr &+ written), remaining, self._offset));
+            n := io.await(IO_file.write(the_fd, buf_ptr &+ written, remaining, self._offset));
             cond(
               (n < i32(0)) => {
-                write_err = .Some(IOError.from_errno((i32(0) - n)));
+                write_err =.Some(IOError.from_errno(i32(0) - n));
               },
               true => {
                 written = (written + usize(n));
                 self._offset = (self._offset + u64(n));
               }
             );
-          };
-
+          });
           self._buf = ArrayList(u8).with_capacity(self._capacity);
         },
         true => ()
       );
-
-      match(write_err,
-        .Some(e) => .Err(e),
-        .None => .Ok(())
+      match(
+        write_err,
+        .Some(e) =>.Err(e),
+        .None =>.Ok(())
       )
     })
   }),
-
   // Write bytes from a pointer into the buffer.
   // Automatically flushes when the buffer is full.
   // Returns total number of bytes written.
-  write : (fn(self: Self, data: *(u8), size: u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  write : (fn(self : Self, data : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
     the_fd := self._fd;
     io.async((using(io : IO)) => {
       remaining := usize(size);
       src_pos := usize(0);
-      (write_err : Option(IOError)) = .None;
-
-      while runtime(((remaining > usize(0)) && write_err.is_none())), {
+      (write_err : Option(IOError)) =.None;
+      while(runtime((remaining > usize(0)) && write_err.is_none()), {
         space := (self._capacity - self._buf.len());
         cond(
           (space == usize(0)) => {
             // Buffer full, flush it
             flush_result := io.await(self._flush_inner(using(io)));
-            match(flush_result,
-              .Err(e) => { write_err = .Some(e); },
+            match(
+              flush_result,
+              .Err(e) => {
+                write_err =.Some(e);
+              },
               .Ok(_) => ()
             );
           },
@@ -125,47 +116,43 @@ impl(BufWriter,
               true => space
             );
             i := usize(0);
-            while runtime((i < to_copy)), {
+            while(runtime(i < to_copy), {
               self._buf.push((data &+ (src_pos + i)).*);
               i = (i + usize(1));
-            };
+            });
             src_pos = (src_pos + to_copy);
             remaining = (remaining - to_copy);
           }
         );
-      };
-
-      match(write_err,
-        .Some(e) => .Err(e),
-        .None => .Ok(i32(size))
+      });
+      match(
+        write_err,
+        .Some(e) =>.Err(e),
+        .None =>.Ok(i32(size))
       )
     })
   }),
-
   // Write a String to the buffer.
-  write_string : (fn(self: Self, s: String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
+  write_string : (fn(self : Self, s : String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
     io.async((using(io : IO)) => {
       bytes := s.as_bytes();
       result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), using(io)));
       result
     })
   ),
-
   // Write bytes from an ArrayList to the buffer.
-  write_bytes : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
+  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
     io.async((using(io : IO)) => {
       result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), using(io)));
       result
     })
   ),
-
   // Flush all buffered data to the underlying file descriptor.
-  flush : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
+  flush : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
     io.async((using(io : IO)) => {
       flush_result := io.await(self._flush_inner(using(io)));
       flush_result
     })
   )
 );
-
-export BufWriter;
+export(BufWriter);

package/std/sys/clock.yo

@@ -2,22 +2,17 @@
 //!
 //! Provides a synchronous wrapper for reading wall-clock and monotonic time.
 //! Returns 0 on success, -errno / negative platform error on failure.
-
-{ platform, Platform } :: import "../process";
-{ __yo_sync_clock_gettime } :: import "./externs.yo";
-
+{ platform, Platform } :: import("../process");
+{ __yo_sync_clock_gettime } :: import("./externs.yo");
 // Wall clock time (Unix epoch seconds + nanoseconds)
 CLOCK_REALTIME :: i32(0);
-
 // Monotonic time (non-decreasing; use for durations)
 CLOCK_MONOTONIC :: cond(
   (platform == Platform.Macos) => i32(6),
   true => i32(1)
 );
-
 // Read current time from the selected clock source.
-clock_gettime :: (fn(clock_id: i32, sec: *(i64), nsec: *(i64)) -> i32)(
+clock_gettime :: (fn(clock_id : i32, sec : *(i64), nsec : *(i64)) -> i32)(
   __yo_sync_clock_gettime(clock_id, sec, nsec)
 );
-
-export CLOCK_REALTIME, CLOCK_MONOTONIC, clock_gettime;
+export(CLOCK_REALTIME, CLOCK_MONOTONIC, clock_gettime);