@shd101wyy/yo 0.1.25 → 0.1.27

package/std/fs/file.yo

@@ -26,45 +26,38 @@
 //!   f := io.await(File.open(Path.new(`test.txt`), .Read));
 //! });
 //! ```
-
-{ GlobalAllocator } :: import "../allocator";
+{ GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ ArrayList } :: import "../collections/array_list";
-open import "../string";
-open import "../fmt";
-{ Path } :: import "../path";
-{ IOError } :: import "../sys/errors";
-{ Error, AnyError, Exception } :: import "../error";
-{ Metadata } :: import "./metadata";
-_metadata_mod :: import "./metadata";
-{ Statx } :: import "../sys/statx";
-IO_path :: import "../sys/path";
-{ OpenMode, FilePermission, SeekFrom, _open_mode_to_flags, _open_mode_needs_perm, _seek_from_to_whence } :: import "./types";
-IO_file :: import "../sys/file";
-IO_seek :: import "../sys/seek";
-{
-  AT_FDCWD, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS,
-  O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND,
-  O_CLOEXEC, DEFAULT_FILE_MODE
-} :: import "../sys/constants";
-
+{ ArrayList } :: import("../collections/array_list");
+open(import("../string"));
+open(import("../fmt"));
+{ Path } :: import("../path");
+{ IOError } :: import("../sys/errors");
+{ Error, AnyError, Exception } :: import("../error");
+{ Metadata } :: import("./metadata");
+_metadata_mod :: import("./metadata");
+{ Statx } :: import("../sys/statx");
+IO_path :: import("../sys/path");
+{ OpenMode, FilePermission, SeekFrom, _open_mode_to_flags, _open_mode_needs_perm, _seek_from_to_whence } :: import("./types");
+IO_file :: import("../sys/file");
+IO_seek :: import("../sys/seek");
+{ AT_FDCWD, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, O_CLOEXEC, DEFAULT_FILE_MODE } :: import("../sys/constants");
 // ============================================================================
 // File
 // ============================================================================
-
 /// An open file handle with async read/write operations.
 ///
 /// Provides methods for reading, writing, seeking, and querying file metadata.
 /// Files are automatically closed when disposed.
 File :: object(
-  _fd       : i32,
-  _path     : Path,
+  _fd : i32,
+  _path : Path,
   _is_closed : bool
 );
-
-impl(File,
+impl(
+  File,
   /// Open a file at `path` with the given mode and custom permissions.
-  open_with : (fn(path: Path, mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))({
+  open_with : (fn(path : Path, mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))({
     flags := _open_mode_to_flags(mode);
     file_mode := cond(
       _open_mode_needs_perm(mode) => i32(perm.mode),
@@ -77,51 +70,44 @@ impl(File,
       result := io.await(IO_file.openat(AT_FDCWD, cstr, flags, file_mode));
       fd := IOError.check(result);
       File(
-        _fd: fd,
-        _path: path,
-        _is_closed: false
+        _fd : fd,
+        _path : path,
+        _is_closed : false
       )
     })
   }),
-
   /// Open a file from a `str` path with the given mode and custom permissions.
-  open_with_str : (fn(path: str, mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+  open_with_str : (fn(path : str, mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
     File.open_with(Path.new(String.from(path)), mode, perm)
   ),
-
   /// Open a file from a C string path with the given mode and custom permissions.
-  open_with_cstr : (fn(path: *(u8), mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+  open_with_cstr : (fn(path : *(u8), mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
     File.open_with(Path.from_cstr(path), mode, perm)
   ),
-
   /// Open a file at `path` with the given mode and default permissions (0o644).
-  open : (fn(path: Path, mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+  open : (fn(path : Path, mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
     File.open_with(path, mode, FilePermission.default())
   ),
-
   /// Open a file from a `str` path with the given mode and default permissions.
-  open_str : (fn(path: str, mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+  open_str : (fn(path : str, mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
     File.open(Path.new(String.from(path)), mode)
   ),
-
   /// Open a file from a C string path with the given mode and default permissions.
-  open_cstr : (fn(path: *(u8), mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+  open_cstr : (fn(path : *(u8), mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
     File.open(Path.from_cstr(path), mode)
   ),
-
   /// Read up to `size` bytes into the buffer `buf`.
   /// Returns the number of bytes actually read.
-  read : (fn(self: Self, buf: *(u8), size: u32, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     io.async((using(io, exn)) => {
       result := io.await(IO_file.read(fd, buf, size, u64(0)));
       IOError.check(result)
     })
   }),
-
   /// Write a `String` to the file.
   /// Returns the number of bytes written.
-  write_string : (fn(self: Self, data: String, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_string : (fn(self : Self, data : String, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     io.async((using(io, exn)) => {
       data_bytes := data.as_bytes();
@@ -134,233 +120,211 @@ impl(File,
       )
     })
   }),
-
   /// Write bytes from an `ArrayList(u8)` to the file.
   /// Returns the number of bytes written.
-  write_bytes : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io, exn)) =>
-      cond(
-        (data.len() == usize(0)) => i32(0),
-        true => {
-          result := io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)));
-          IOError.check(result)
-        }
-      )
+    io.async(
+      (using(io, exn)) =>
+        cond(
+          (data.len() == usize(0)) => i32(0),
+          true => {
+            result := io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)));
+            IOError.check(result)
+          }
+        )
     )
   }),
-
   /// Read the entire file contents into an `ArrayList(u8)`.
-  read_bytes : (fn(self: Self, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
+  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
     fd := self._fd;
     io.async((using(io, exn)) => {
       buf_size := usize(4096);
       buf := *(u8)(malloc(buf_size).unwrap());
       result := ArrayList(u8).new();
       offset := u64(0);
-      while runtime(true), {
+      while(runtime(true), {
         n := io.await(IO_file.read(fd, buf, u32(buf_size), offset));
         cond(
           (n < i32(0)) => {
             free(.Some(*(void)(buf)));
-            exn.throw(dyn IOError.from_errno((i32(0) - n)));
+            exn.throw(dyn(IOError.from_errno(i32(0) - n)));
           },
           (n == i32(0)) => break,
           true => {
             offset = (offset + u64(n));
             i := usize(0);
-            while runtime((i < usize(n))), {
+            while(runtime(i < usize(n)), {
               result.push((buf &+ i).*);
               i = (i + usize(1));
-            };
+            });
           }
         );
-      };
+      });
       free(.Some(*(void)(buf)));
       result
     })
   }),
-
   /// Read the entire file contents into a `String`.
-  read_string : (fn(self: Self, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+  read_string : (fn(self : Self, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
     io.async((using(io, exn)) => {
       bytes := io.await(self.read_bytes());
       String.from_bytes(bytes)
     })
   ),
-
   /// Flush (fsync) file data to disk.
-  flush : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  flush : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io, exn)) => {
       result := io.await(IO_file.fsync(fd));
       cond(
-        (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+        (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
         true => ()
       )
     })
   }),
-
   /// Seek to a position relative to `from`. Returns the new absolute byte offset.
-  seek : (fn(self: Self, offset: i64, from: SeekFrom, using(exn : Exception)) -> i64)({
+  seek : (fn(self : Self, offset : i64, from : SeekFrom, using(exn : Exception)) -> i64)({
     result := IO_seek.lseek(self._fd, offset, _seek_from_to_whence(from));
     cond(
-      (result < i64(0)) => exn.throw(dyn IOError.from_errno(i32((i64(0) - result)))),
+      (result < i64(0)) => exn.throw(dyn(IOError.from_errno(i32(i64(0) - result)))),
       true => result
     )
   }),
-
   /// Get the current file position (byte offset from the beginning).
-  position : (fn(self: Self) -> i64)(
+  position : (fn(self : Self) -> i64)(
     IO_seek.lseek(self._fd, i64(0), IO_seek.SEEK_CUR)
   ),
-
   /// Get the file size in bytes.
-  size : (fn(self: Self) -> i64)(
+  size : (fn(self : Self) -> i64)(
     IO_file.file_size(self._fd)
   ),
-
   /// Close the file descriptor. Safe to call multiple times.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io, exn)) =>
-      cond(
-        self._is_closed => (),
-        true => {
-          result := io.await(IO_file.close(fd));
-          self._is_closed = true;
-          cond(
-            (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
-            true => ()
-          )
-        }
-      )
+    io.async(
+      (using(io, exn)) =>
+        cond(
+          self._is_closed => (),
+          true => {
+            result := io.await(IO_file.close(fd));
+            self._is_closed = true;
+            cond(
+              (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
+              true => ()
+            )
+          }
+        )
     )
   }),
-
   /// Get the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     self._fd
   ),
-
   /// Get the path this file was opened with.
-  path : (fn(self: Self) -> Path)(
+  path : (fn(self : Self) -> Path)(
     self._path
   ),
-
   /// Get file metadata (size, permissions, timestamps).
-  metadata : (fn(self: Self, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
+  metadata : (fn(self : Self, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
     _metadata_mod.metadata(self._path)
   )
 );
-
-impl(File, Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    cond(
-      (!(self._is_closed)) => {
-        IO_file.close_sync(self._fd);
-        self._is_closed = true;
-      },
-      true => ()
-    );
-  })
-));
-
-export File, OpenMode, FilePermission, SeekFrom;
-
+impl(
+  File,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      cond(
+        (!(self._is_closed)) => {
+          IO_file.close_sync(self._fd);
+          self._is_closed = true;
+        },
+        true => ()
+      );
+    })
+  )
+);
+export(File, OpenMode, FilePermission, SeekFrom);
 // ============================================================================
 // Convenience functions
 // ============================================================================
-
 /// Read an entire file into a `String`.
-read_string :: (fn(path: Path, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+read_string :: (fn(path : Path, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
   io.async((using(io, exn)) => {
-    file := io.await(File.open(path, .Read));
+    file := io.await(File.open(path,.Read));
     content := io.await(file.read_string());
     io.await(file.close());
-    return content;
+    return(content);
   })
 );
-
 /// Read an entire file into a `String` (`str` path variant).
-read_string_str :: (fn(path: str, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+read_string_str :: (fn(path : str, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
   read_string(Path.new(String.from(path)))
 );
-
 /// Read an entire file into a `String` (C string path variant).
-read_string_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+read_string_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(String, IO, Exception)))(
   read_string(Path.from_cstr(path))
 );
-
 /// Read an entire file into a byte list (`ArrayList(u8)`).
-read_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
+read_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
   io.async((using(io, exn)) => {
-    file := io.await(File.open(path, .Read));
+    file := io.await(File.open(path,.Read));
     content := io.await(file.read_bytes());
     io.await(file.close());
-    return content;
+    return(content);
   })
 );
-
 /// Read an entire file into bytes (`str` path variant).
-read_file_str :: (fn(path: str, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
+read_file_str :: (fn(path : str, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
   read_file(Path.new(String.from(path)))
 );
-
 /// Read an entire file into bytes (C string path variant).
-read_file_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
+read_file_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
   read_file(Path.from_cstr(path))
 );
-
 /// Write a `String` to a file, creating or truncating it.
-write_file :: (fn(path: Path, data: String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+write_file :: (fn(path : Path, data : String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
-    file := io.await(File.open(path, .Write));
+    file := io.await(File.open(path,.Write));
     io.await(file.write_string(data));
     io.await(file.close());
   })
 );
-
 /// Write a `str` to a file, creating or truncating it (`str` path variant).
-write_file_str :: (fn(path: str, data: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+write_file_str :: (fn(path : str, data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   write_file(Path.new(String.from(path)), String.from(data))
 );
-
 /// Write a `str` to a file, creating or truncating it (C string path variant).
-write_file_cstr :: (fn(path: *(u8), data: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+write_file_cstr :: (fn(path : *(u8), data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   write_file(Path.from_cstr(path), String.from(data))
 );
-
 /// Write bytes to a file, creating or truncating it.
-write_bytes :: (fn(path: Path, data: ArrayList(u8), using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+write_bytes :: (fn(path : Path, data : ArrayList(u8), using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
-    file := io.await(File.open(path, .Write));
+    file := io.await(File.open(path,.Write));
     io.await(file.write_bytes(data));
     io.await(file.close());
   })
 );
-
 /// Append a `String` to a file, creating it if it does not exist.
-append_file :: (fn(path: Path, data: String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+append_file :: (fn(path : Path, data : String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
-    file := io.await(File.open(path, .Append));
+    file := io.await(File.open(path,.Append));
     io.await(file.write_string(data));
     io.await(file.close());
   })
 );
-
 /// Append a `str` to a file (`str` path variant).
-append_file_str :: (fn(path: str, data: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+append_file_str :: (fn(path : str, data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   append_file(Path.new(String.from(path)), String.from(data))
 );
-
-extern "Yo",
+extern(
+  "Yo",
   __yo_statx_buf_size : (fn() -> usize)
-;
-
+);
 /// Check if a path exists. Returns `false` for any error including file not found.
 /// Does not use the `Exception` effect.
-exists :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
+exists :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   io.async((using(io : IO)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
@@ -368,22 +332,19 @@ exists :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
     buf := *(u8)(malloc(buf_size).unwrap());
     result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
     free(.Some(*(void)(buf)));
-    (result >= i32(0))
+    result >= i32(0)
   })
 );
-
 /// Check if a path exists (`str` path variant).
-exists_str :: (fn(path: str, using(io : IO)) -> Impl(Future(bool, IO)))(
+exists_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
   exists(Path.new(String.from(path)), using(io))
 );
-
 /// Check if a path exists (C string path variant).
-exists_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
+exists_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
   exists(Path.from_cstr(path), using(io))
 );
-
 /// Check if a path is a regular file. Returns `false` for any error.
-is_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
+is_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   io.async((using(io : IO)) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -394,7 +355,7 @@ is_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
     r := cond(
       (result < i32(0)) => false,
       true => {
-        sx := Statx(_buf_ptr: buf, _buf_size: buf_size);
+        sx := Statx(_buf_ptr : buf, _buf_size : buf_size);
         sx.is_file()
       }
     );
@@ -402,19 +363,16 @@ is_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
     r
   })
 );
-
 /// Check if a path is a regular file (`str` path variant).
-is_file_str :: (fn(path: str, using(io : IO)) -> Impl(Future(bool, IO)))(
+is_file_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
   is_file(Path.new(String.from(path)), using(io))
 );
-
 /// Check if a path is a regular file (C string path variant).
-is_file_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
+is_file_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
   is_file(Path.from_cstr(path), using(io))
 );
-
 /// Check if a path is a directory. Returns `false` for any error.
-is_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
+is_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   io.async((using(io : IO)) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -425,7 +383,7 @@ is_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
     r := cond(
       (result < i32(0)) => false,
       true => {
-        sx := Statx(_buf_ptr: buf, _buf_size: buf_size);
+        sx := Statx(_buf_ptr : buf, _buf_size : buf_size);
         sx.is_directory()
       }
     );
@@ -433,20 +391,17 @@ is_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
     r
   })
 );
-
 /// Check if a path is a directory (`str` path variant).
-is_dir_str :: (fn(path: str, using(io : IO)) -> Impl(Future(bool, IO)))(
+is_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
   is_dir(Path.new(String.from(path)), using(io))
 );
-
 /// Check if a path is a directory (C string path variant).
-is_dir_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
+is_dir_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
   is_dir(Path.from_cstr(path), using(io))
 );
-
 /// Resolve a path to its canonical absolute form (resolves symlinks, `.` and `..`).
 /// Throws if the path does not exist.
-canonical :: (fn(path: Path, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
+canonical :: (fn(path : Path, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
   io.async((using(io, exn)) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
@@ -472,25 +427,37 @@ canonical :: (fn(path: Path, using(io : IO)) -> Impl(Future(Path, IO, Exception)
     Path.new(resolved)
   })
 );
-
 /// Resolve a path to its canonical absolute form (`str` path variant).
-canonical_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
+canonical_str :: (fn(path : str, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
   canonical(Path.new(String.from(path)))
 );
-
 /// Resolve a path to its canonical absolute form (C string path variant).
-canonical_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
+canonical_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
   canonical(Path.from_cstr(path))
 );
-
-export
-  read_string, read_string_str, read_string_cstr,
-  read_file, read_file_str, read_file_cstr,
-  write_file, write_file_str, write_file_cstr,
+export(
+  read_string,
+  read_string_str,
+  read_string_cstr,
+  read_file,
+  read_file_str,
+  read_file_cstr,
+  write_file,
+  write_file_str,
+  write_file_cstr,
   write_bytes,
-  append_file, append_file_str,
-  exists, exists_str, exists_cstr,
-  is_file, is_file_str, is_file_cstr,
-  is_dir, is_dir_str, is_dir_cstr,
-  canonical, canonical_str, canonical_cstr
-;
+  append_file,
+  append_file_str,
+  exists,
+  exists_str,
+  exists_cstr,
+  is_file,
+  is_file_str,
+  is_file_cstr,
+  is_dir,
+  is_dir_str,
+  is_dir_cstr,
+  canonical,
+  canonical_str,
+  canonical_cstr
+);