@shd101wyy/yo 0.0.29 → 0.0.31

package/std/fs/file.yo

@@ -34,7 +34,9 @@ open import "../fmt";
 { Error, AnyError, Exception } :: import "../error";
 { Metadata } :: import "./metadata";
 _metadata_mod :: import "./metadata";
-{ OpenMode, FilePermission, _open_mode_to_flags, _open_mode_needs_perm } :: import "./types";
+{ 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";
 {
@@ -193,9 +195,8 @@ impl(File,
   }),
 
   // Seek to a position. Returns the new absolute position.
-  // whence: SEEK_SET(0), SEEK_CUR(1), SEEK_END(2)
-  seek : (fn(self: Self, offset: i64, whence: i32, using(exn : Exception)) -> i64)({
-    result := IO_seek.lseek(self._fd, offset, whence);
+  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)))),
       true => result
@@ -258,7 +259,7 @@ impl(File, Dispose(
   })
 ));
 
-export File, OpenMode, FilePermission;
+export File, OpenMode, FilePermission, SeekFrom;
 
 // ============================================================================
 // Convenience functions
@@ -374,11 +375,117 @@ 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 (including file not found).
+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();
+    cstr := cstr_bytes.ptr().unwrap();
+    buf_size := __yo_statx_buf_size();
+    buf := *(u8)(malloc(buf_size).unwrap());
+    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    r := cond(
+      (result < i32(0)) => false,
+      true => {
+        sx := Statx(_buf_ptr: buf, _buf_size: buf_size);
+        sx.is_file()
+      }
+    );
+    free(.Some(*(void)(buf)));
+    r
+  })
+);
+
+// Check if a path is a regular file (str version).
+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 version).
+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 (including file not found).
+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();
+    cstr := cstr_bytes.ptr().unwrap();
+    buf_size := __yo_statx_buf_size();
+    buf := *(u8)(malloc(buf_size).unwrap());
+    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    r := cond(
+      (result < i32(0)) => false,
+      true => {
+        sx := Statx(_buf_ptr: buf, _buf_size: buf_size);
+        sx.is_directory()
+      }
+    );
+    free(.Some(*(void)(buf)));
+    r
+  })
+);
+
+// Check if a path is a directory (str version).
+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 version).
+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 on error (e.g. path does not exist).
+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();
+    cstr := cstr_bytes.ptr().unwrap();
+    // Async stat to verify path exists (provides await point for proper RC cleanup)
+    buf_size := __yo_statx_buf_size();
+    stat_buf := *(u8)(malloc(buf_size).unwrap());
+    stat_result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, stat_buf));
+    free(.Some(*(void)(stat_buf)));
+    IOError.check(stat_result);
+    // Resolve the canonical path
+    resolved_buf := *(u8)(malloc(usize(4096)).unwrap());
+    rp_result := IO_path.realpath(cstr, resolved_buf);
+    cond(
+      (rp_result < i32(0)) => {
+        free(.Some(*(void)(resolved_buf)));
+        IOError.check(rp_result);
+      },
+      true => ()
+    );
+    resolved := String.from_cstr(resolved_buf).unwrap();
+    free(.Some(*(void)(resolved_buf)));
+    Path.new(resolved)
+  })
+);
+
+// Resolve a path to its canonical absolute form (str version).
+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 version).
+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,
   write_bytes,
   append_file, append_file_str,
-  exists, exists_str, exists_cstr
+  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
 ;

package/std/fs/types.yo

@@ -76,3 +76,24 @@ impl(FilePermission,
 );
 
 export FilePermission;
+
+// ============================================================================
+// SeekFrom — file seek position reference
+// ============================================================================
+
+SeekFrom :: enum(
+  Start,    // Seek from the beginning of the file
+  Current,  // Seek relative to the current position
+  End       // Seek relative to the end of the file
+);
+
+// Convert SeekFrom to POSIX whence constant (i32).
+_seek_from_to_whence :: (fn(from: SeekFrom) -> i32)(
+  match(from,
+    .Start   => i32(0),
+    .Current => i32(1),
+    .End     => i32(2)
+  )
+);
+
+export SeekFrom, _seek_from_to_whence;

package/std/glob/glob.yo

@@ -0,0 +1,206 @@
+open import "../string";
+{ ArrayList } :: import "../collections/array_list";
+
+// Recursive byte-level glob pattern matching
+_glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usize) -> bool)({
+  // Base: both pattern and text consumed
+  cond(
+    ((pi == pb.len()) && (ti == tb.len())) => {
+      return true;
+    },
+    true => ()
+  );
+
+  // Pattern consumed but text remains
+  cond(
+    (pi == pb.len()) => {
+      return false;
+    },
+    true => ()
+  );
+
+  p := pb.get(pi).unwrap();
+
+  // Handle * and **
+  cond(
+    (p == u8(42)) => {
+      is_dbl := cond(
+        ((pi + usize(1)) < pb.len()) => (pb.get((pi + usize(1))).unwrap() == u8(42)),
+        true => false
+      );
+      cond(
+        is_dbl => {
+          // ** matches any characters including /
+          npi := (pi + usize(2));
+          // Skip optional trailing /
+          cond(
+            (npi < pb.len()) => {
+              cond(
+                (pb.get(npi).unwrap() == u8(47)) => {
+                  npi = (npi + usize(1));
+                },
+                true => ()
+              );
+            },
+            true => ()
+          );
+          // Try ** matching nothing
+          cond(
+            recur(pb, npi, tb, ti) => {
+              return true;
+            },
+            true => ()
+          );
+          // Try ** consuming one char
+          cond(
+            (ti < tb.len()) => {
+              return recur(pb, pi, tb, (ti + usize(1)));
+            },
+            true => {
+              return false;
+            }
+          );
+        },
+        true => {
+          // Single * matches any except /
+          // Try * matching nothing
+          cond(
+            recur(pb, (pi + usize(1)), tb, ti) => {
+              return true;
+            },
+            true => ()
+          );
+          // Try * consuming one non-/ char
+          cond(
+            (ti < tb.len()) => {
+              tc := tb.get(ti).unwrap();
+              cond(
+                (tc != u8(47)) => {
+                  return recur(pb, pi, tb, (ti + usize(1)));
+                },
+                true => {
+                  return false;
+                }
+              );
+            },
+            true => {
+              return false;
+            }
+          );
+        }
+      );
+    },
+    true => ()
+  );
+
+  // Text consumed but non-star pattern remains
+  cond(
+    (ti == tb.len()) => {
+      return false;
+    },
+    true => ()
+  );
+
+  t := tb.get(ti).unwrap();
+
+  // Handle ?
+  cond(
+    (p == u8(63)) => {
+      cond(
+        (t != u8(47)) => {
+          return recur(pb, (pi + usize(1)), tb, (ti + usize(1)));
+        },
+        true => {
+          return false;
+        }
+      );
+    },
+    true => ()
+  );
+
+  // Handle [...]
+  cond(
+    (p == u8(91)) => {
+      ci := (pi + usize(1));
+      neg := false;
+      // Check for negation: ! or ^
+      cond(
+        (ci < pb.len()) => {
+          nc := pb.get(ci).unwrap();
+          cond(
+            ((nc == u8(33)) || (nc == u8(94))) => {
+              neg = true;
+              ci = (ci + usize(1));
+            },
+            true => ()
+          );
+        },
+        true => ()
+      );
+      // Scan characters in class until ]
+      found := false;
+      cdone := false;
+      while (((ci < pb.len()) && (!(cdone)))), (ci = (ci + usize(1))), {
+        ch := pb.get(ci).unwrap();
+        cond(
+          (ch == u8(93)) => {
+            cdone = true;
+          },
+          true => {
+            cond(
+              (ch == t) => {
+                found = true;
+              },
+              true => ()
+            );
+          }
+        );
+      };
+      // Malformed pattern (no closing ])
+      cond(
+        (!(cdone)) => {
+          return false;
+        },
+        true => ()
+      );
+      matched := cond(
+        neg => !(found),
+        true => found
+      );
+      cond(
+        matched => {
+          return recur(pb, ci, tb, (ti + usize(1)));
+        },
+        true => {
+          return false;
+        }
+      );
+    },
+    true => ()
+  );
+
+  // Literal byte match
+  cond(
+    (p == t) => recur(pb, (pi + usize(1)), tb, (ti + usize(1))),
+    true => false
+  )
+});
+
+glob_match :: (fn(pattern: String, text: String) -> bool)(
+  _glob_match_impl(pattern._bytes, usize(0), text._bytes, usize(0))
+);
+
+GlobPattern :: object(
+  _pattern : String
+);
+
+impl(GlobPattern,
+  new : (fn(pattern: String) -> Self)(
+    Self(_pattern: pattern)
+  ),
+  matches : (fn(self: Self, text: String) -> bool)(
+    _glob_match_impl(self._pattern._bytes, usize(0), text._bytes, usize(0))
+  )
+);
+
+export glob_match, GlobPattern;

package/std/http/http.yo

@@ -0,0 +1,196 @@
+// std/http/http.yo - HTTP types and request/response builders
+
+open import "../string";
+{ ArrayList } :: import "../collections/array_list";
+{ ToString } :: import "../fmt";
+
+HttpMethod :: enum(GET, POST, PUT, DELETE, HEAD, PATCH);
+
+impl(HttpMethod, ToString(
+  to_string : (self ->
+    match(self,
+      .GET => `GET`,
+      .POST => `POST`,
+      .PUT => `PUT`,
+      .DELETE => `DELETE`,
+      .HEAD => `HEAD`,
+      .PATCH => `PATCH`
+    )
+  )
+));
+
+HttpHeader :: object(name: String, value: String);
+
+impl(HttpHeader,
+  new : (fn(name: String, value: String) -> Self)(
+    Self(name: name, value: value)
+  )
+);
+
+HttpRequest :: object(
+  method: HttpMethod,
+  path: String,
+  headers: ArrayList(HttpHeader),
+  body: String
+);
+
+impl(HttpRequest,
+  new : (fn(method: HttpMethod, path: String) -> Self)(
+    Self(method: method, path: path, headers: ArrayList(HttpHeader).new(), body: ``)
+  ),
+
+  header : (fn(self: Self, name: String, value: String) -> Self)({
+    self.headers.push(HttpHeader.new(name, value));
+    self
+  }),
+
+  with_body : (fn(self: Self, body: String) -> Self)({
+    self.body = body;
+    self
+  }),
+
+  set_host : (fn(self: Self, host: String) -> unit)({
+    self.headers.push(HttpHeader.new(`Host`, host));
+  }),
+
+  set_header : (fn(self: Self, name: String, value: String) -> unit)({
+    self.headers.push(HttpHeader.new(name, value));
+  }),
+
+  set_body : (fn(self: Self, body: String) -> unit)({
+    self.body = body;
+  }),
+
+  to_string : (fn(self: Self) -> String)({
+    result := `${self.method.to_string()} ${self.path} HTTP/1.1\r\n`;
+    i := usize(0);
+    while (i < self.headers.len()), (i = (i + usize(1))), {
+      h := self.headers.get(i).unwrap();
+      result = `${result}${h.name}: ${h.value}\r\n`;
+    };
+    result = `${result}\r\n`;
+    cond(
+      (!(self.body.is_empty())) => { result = `${result}${self.body}`; },
+      true => ()
+    );
+    result
+  })
+);
+
+HttpResponse :: object(
+  status_code: i32,
+  status_text: String,
+  headers: ArrayList(HttpHeader),
+  body: String
+);
+
+impl(HttpResponse,
+  new : (fn(status_code: i32, status_text: String) -> Self)(
+    Self(status_code: status_code, status_text: status_text, headers: ArrayList(HttpHeader).new(), body: ``)
+  ),
+
+  get_header : (fn(self: Self, name: String) -> Option(String))({
+    lower_name := name.to_lowercase();
+    i := usize(0);
+    while (i < self.headers.len()), (i = (i + usize(1))), {
+      h := self.headers.get(i).unwrap();
+      cond((h.name.to_lowercase() == lower_name) => { return .Some(h.value); }, true => ());
+    };
+    .None
+  }),
+
+  is_ok : (fn(self: Self) -> bool)(
+    ((self.status_code >= i32(200)) && (self.status_code < i32(300)))
+  ),
+
+  is_redirect : (fn(self: Self) -> bool)(
+    ((self.status_code >= i32(300)) && (self.status_code < i32(400)))
+  ),
+
+  is_error : (fn(self: Self) -> bool)(
+    (self.status_code >= i32(400))
+  )
+);
+
+parse_response :: (fn(raw: String) -> Result(HttpResponse, String))({
+  lines := raw.split(`\r\n`);
+  cond((lines.len() == usize(0)) => { return .Err(`Empty response`); }, true => ());
+
+  status_line := lines.get(usize(0)).unwrap();
+  cond((!(status_line.starts_with(`HTTP/`))) => { return .Err(`Invalid status line`); }, true => ());
+
+  sp1_opt := status_line.index_of(` `);
+  cond(sp1_opt.is_none() => { return .Err(`Invalid status line format`); }, true => ());
+  sp1 := sp1_opt.unwrap();
+  rest := status_line.substring((sp1 + usize(1)), status_line.len());
+
+  sp2_opt := rest.index_of(` `);
+  cond(sp2_opt.is_none() => { return .Err(`Invalid status line format`); }, true => ());
+  sp2 := sp2_opt.unwrap();
+  code_str := rest.substring(usize(0), sp2);
+  status_text := rest.substring((sp2 + usize(1)), rest.len());
+
+  code_opt := code_str.parse_i32();
+  cond(code_opt.is_none() => { return .Err(`Invalid status code`); }, true => ());
+  code := code_opt.unwrap();
+
+  resp := HttpResponse.new(code, status_text);
+
+  j := usize(1);
+  body_start := lines.len();
+  while (j < lines.len()), (j = (j + usize(1))), {
+    hline := lines.get(j).unwrap();
+    cond(
+      hline.is_empty() => {
+        body_start = (j + usize(1));
+        break;
+      },
+      true => {
+        colon_opt := hline.index_of(`:`);
+        cond(
+          colon_opt.is_some() => {
+            colon := colon_opt.unwrap();
+            hname := hline.substring(usize(0), colon).trim();
+            hval := hline.substring((colon + usize(1)), hline.len()).trim();
+            resp.headers.push(HttpHeader.new(hname, hval));
+          },
+          true => ()
+        );
+      }
+    );
+  };
+
+  cond(
+    (body_start < lines.len()) => {
+      resp.body = lines.get(body_start).unwrap();
+      m := (body_start + usize(1));
+      while (m < lines.len()), (m = (m + usize(1))), {
+        resp.body = `${resp.body}\r\n${lines.get(m).unwrap()}`;
+      };
+    },
+    true => ()
+  );
+
+  .Ok(resp)
+});
+
+http_status_text :: (fn(code: i32) -> String)(
+  cond(
+    (code == i32(200)) => `OK`,
+    (code == i32(201)) => `Created`,
+    (code == i32(204)) => `No Content`,
+    (code == i32(301)) => `Moved Permanently`,
+    (code == i32(302)) => `Found`,
+    (code == i32(304)) => `Not Modified`,
+    (code == i32(400)) => `Bad Request`,
+    (code == i32(404)) => `Not Found`,
+    (code == i32(405)) => `Method Not Allowed`,
+    (code == i32(500)) => `Internal Server Error`,
+    (code == i32(502)) => `Bad Gateway`,
+    (code == i32(503)) => `Service Unavailable`,
+    true => `Unknown`
+  )
+);
+
+export HttpMethod, HttpHeader, HttpRequest, HttpResponse;
+export parse_response, http_status_text;

package/std/io/reader.yo

@@ -0,0 +1,17 @@
+// std/io/reader.yo - Reader trait for byte-level input
+//
+// Provides a common interface for reading bytes from various sources
+// (files, network streams, buffers, etc.)
+
+{ Exception } :: import "../error";
+
+// Reader trait — synchronous byte reading interface.
+// Types implementing Reader provide `read` for reading into a buffer.
+Reader :: trait(
+  // Read up to `size` bytes into buffer `buf`.
+  // Returns the number of bytes actually read (0 at end-of-stream).
+  read :
+    fn(self: *(Self), buf: *(u8), size: usize, using(exn : Exception)) -> usize
+);
+
+export Reader;

package/std/io/writer.yo

@@ -0,0 +1,19 @@
+// std/io/writer.yo - Writer trait for byte-level output
+//
+// Provides a common interface for writing bytes to various destinations
+// (files, network streams, buffers, etc.)
+
+{ Exception } :: import "../error";
+
+// Writer trait — synchronous byte writing interface.
+Writer :: trait(
+  // Write bytes from buffer. Returns number of bytes written.
+  write :
+    fn(self: *(Self), buf: *(u8), size: usize, using(exn : Exception)) -> usize,
+
+  // Flush any buffered data to the underlying destination.
+  flush :
+    fn(self: *(Self), using(exn : Exception)) -> unit
+);
+
+export Writer;

package/std/net/tcp.yo

@@ -268,7 +268,7 @@ impl(TcpStream,
   }),
 
   // Read all available data into a byte list.
-  read_all : (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 : IO, exn : Exception)) => {
       buf_size := usize(4096);

package/std/prelude.yo

@@ -3410,6 +3410,40 @@ impl(forall(T : Type), Option(T),
   )
 );
 
+// Option(T) implements Comptime when T implements Comptime
+impl(forall(T : Type), where(T <: Comptime), Option(T), Comptime());
+
+// Comptime methods for Option(T)
+impl(forall(T : Type), where(T <: Comptime), Option(T),
+  comptime_unwrap : (fn(comptime(self) : Self) -> comptime(T))(
+    match(self,
+      .Some(value) => value,
+      .None => panic("Called comptime_unwrap on a None value")
+    )
+  ),
+
+  comptime_unwrap_or : (fn(comptime(self) : Self, comptime(or_value) : T) -> comptime(T))(
+    match(self,
+      .Some(value) => value,
+      .None => or_value
+    )
+  ),
+
+  comptime_is_some : (fn(comptime(self) : Self) -> comptime(bool))(
+    match(self,
+      .Some(_) => true,
+      .None => false
+    )
+  ),
+
+  comptime_is_none : (fn(comptime(self) : Self) -> comptime(bool))(
+    match(self,
+      .None => true,
+      .Some(_) => false
+    )
+  )
+);
+
 // Alias of the Option type
 ? :: Option;
 // Nullable pointer
@@ -3459,6 +3493,41 @@ impl(forall(OkType : Type, ErrorType : Type), Result(OkType, ErrorType),
     )
   )
 );
+
+// Result(OkType, ErrorType) implements Comptime when both types implement Comptime
+impl(forall(OkType : Type, ErrorType : Type), where(OkType <: Comptime, ErrorType <: Comptime), Result(OkType, ErrorType), Comptime());
+
+// Comptime methods for Result(OkType, ErrorType)
+impl(forall(OkType : Type, ErrorType : Type), where(OkType <: Comptime, ErrorType <: Comptime), Result(OkType, ErrorType),
+  comptime_unwrap : (fn(comptime(self) : Self) -> comptime(OkType))(
+    match(self,
+      .Ok(value) => value,
+      .Err(_) => panic("Called comptime_unwrap on an Err value")
+    )
+  ),
+
+  comptime_unwrap_err : (fn(comptime(self) : Self) -> comptime(ErrorType))(
+    match(self,
+      .Err(error) => error,
+      .Ok(_) => panic("Called comptime_unwrap_err on an Ok value")
+    )
+  ),
+
+  comptime_is_ok : (fn(comptime(self) : Self) -> comptime(bool))(
+    match(self,
+      .Ok(_) => true,
+      .Err(_) => false
+    )
+  ),
+
+  comptime_is_err : (fn(comptime(self) : Self) -> comptime(bool))(
+    match(self,
+      .Err(_) => true,
+      .Ok(_) => false
+    )
+  )
+);
+
 export
   Result
 ;