@shd101wyy/yo 0.0.31 → 0.0.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/build.yo

@@ -6,7 +6,7 @@
 //
 // Usage in build.yo:
 //   build :: import "std/build";
-//   build.project({ name: "my-app", root: "./src/lib.yo" });
+//   mod :: build.module({ name: "my-app", root: "./src/lib.yo" });
 //   exe :: build.executable({ name: "my-app", root: "./src/main.yo" });
 //   install :: build.step("install", "Build all artifacts");
 //   install.depend_on(exe);
@@ -61,12 +61,6 @@ export target_host;
 // Usage: build.executable({ name: "app", root: "./src/main.yo" })
 // Unspecified fields get their default values.
 
-Project :: struct(
-  name : comptime_string,
-  (root : comptime_string) ?= "./src/lib.yo"
-);
-export Project;
-
 Executable :: struct(
   name : comptime_string,
   root : comptime_string,
@@ -100,6 +94,26 @@ TestSuite :: struct(
 );
 export TestSuite;
 
+// ── Build module type ────────────────────────────────────────────────
+// Represents a named source module that declares system library requirements.
+// Modules are the unit of reuse across Yo dependencies.
+
+BuildModule :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  _dep : comptime_string  // dependency name, empty for local modules
+);
+export BuildModule;
+
+// ── Import entry type ────────────────────────────────────────────────
+// Pairs an import name with a module for use with add_import/add_import_list.
+
+ImportEntry :: struct(
+  name : comptime_string,
+  module : BuildModule
+);
+export ImportEntry;
+
 // ── Step type ────────────────────────────────────────────────────────
 // Returned by all build functions. Used to wire dependencies between steps.
 
@@ -118,6 +132,17 @@ impl(Step,
   }),
   link : (fn(comptime(self) : Self, comptime(library) : Step) -> comptime(unit))({
     __yo_build_link(self.name, library.name);
+  }),
+  add_import : (fn(comptime(self) : Self, comptime(entry) : ImportEntry) -> comptime(unit))({
+    __yo_build_add_import(self.name, entry.name, entry.module.name, entry.module._dep);
+  })
+);
+
+// ── Build module methods ─────────────────────────────────────────────
+
+impl(BuildModule,
+  link : (fn(comptime(self) : Self, comptime(library) : Step) -> comptime(unit))({
+    __yo_build_module_link(self.name, library.name);
   })
 );
 
@@ -150,10 +175,10 @@ export PathDependency;
 
 SystemLibrary :: struct(
   name : comptime_string,
-  pkg_config : comptime_string,
   (fallback_include : comptime_string) ?= "",
   (fallback_lib : comptime_string) ?= "",
-  (fallback_link : comptime_string) ?= ""
+  (fallback_link : comptime_string) ?= "",
+  (defines : comptime_string) ?= ""
 );
 export SystemLibrary;
 
@@ -172,6 +197,12 @@ impl(Dependency,
   artifact : (fn(comptime(self) : Self, comptime(artifact_name) : comptime_string) -> comptime(Step))({
     __yo_build_dep_artifact(self.name, artifact_name);
     Step(name: artifact_name, kind: StepKind.StaticLibrary)
+  }),
+  // Get a module from the dependency's build.yo.
+  // Empty module_name defaults to the sole module if exactly one exists.
+  module : (fn(comptime(self) : Self, comptime(module_name) : comptime_string) -> comptime(BuildModule))({
+    _encoded :: __yo_build_dep_module(self.name, module_name);
+    BuildModule(name: module_name, root: "", _dep: self.name)
   })
 );
 
@@ -179,12 +210,6 @@ impl(Dependency,
 // All registration functions return a Step value, allowing steps to be
 // wired together as dependencies via step.depend_on(dep).
 
-// Register project metadata.
-project :: (fn(comptime(config) : Project) -> comptime(unit)) {
-  __yo_build_project(config.name, config.root);
-};
-export project;
-
 // Register an executable artifact. Returns a Step for dependency wiring.
 executable :: (fn(comptime(config) : Executable) -> comptime(Step)) {
   opt_str :: match(config.optimize,
@@ -273,11 +298,27 @@ export path_dependency;
 
 // Register a system C library discovered via pkg-config. Returns a Step for linking.
 system_library :: (fn(comptime(config) : SystemLibrary) -> comptime(Step)) {
-  __yo_build_system_library(config.name, config.pkg_config, config.fallback_include, config.fallback_lib, config.fallback_link);
+  __yo_build_system_library(config.name, config.fallback_include, config.fallback_lib, config.fallback_link, config.defines);
   Step(name: config.name, kind: StepKind.SystemLibrary)
 };
 export system_library;
 
+// ── Module config type ───────────────────────────────────────────────
+
+ModuleConfig :: struct(
+  name : comptime_string,
+  root : comptime_string
+);
+export ModuleConfig;
+
+// Register a named module. Returns a BuildModule for linking system libraries
+// and importing into executables/libraries.
+_module :: (fn(comptime(config) : ModuleConfig) -> comptime(BuildModule)) {
+  __yo_build_module(config.name, config.root);
+  BuildModule(name: config.name, root: config.root, _dep: "")
+};
+export module : _module;
+
 // Declare a user-configurable build option.
 // Returns the option value (from CLI -Dname=value, or the default).
 // Usage: strip :: build.option({ name: "strip", description: "Strip debug symbols", default: "false" });

package/std/{toml → encoding}/toml.yo

@@ -1,7 +1,12 @@
-// std/toml/toml.yo - Basic TOML parser
+// std/encoding/toml.yo - Basic TOML parser
 //
 // Parses a subset of TOML into a TomlValue tree.
 // Supports: strings, integers, booleans, table sections, comments.
+//
+// Example:
+//   { toml_parse, TomlValue } :: import "std/encoding/toml";
+//   // Or via the encoding index:
+//   { toml_parse, TomlValue } :: import "std/encoding";
 
 open import "../string";
 { ArrayList } :: import "../collections/array_list";

package/std/http/client.yo

@@ -0,0 +1,359 @@
+// std/http/client.yo - Async HTTP client using TCP
+//
+// Provides an async HTTP client and a high-level `fetch` function
+// similar to JavaScript's fetch API.
+//
+// Example:
+//   { fetch, HttpResponse } :: import "std/http";
+//   { Exception } :: import "std/error";
+//
+//   main :: (fn(using(io : IO)) -> unit)({
+//     given(exn) := Exception(throw : ((err) -> {
+//       println(err.message());
+//       escape ();
+//     }));
+//     resp := io.await(fetch(`http://example.com/api/data`, using(io)));
+//     println(resp.body);
+//   });
+
+open import "../string";
+{ ArrayList } :: import "../collections/array_list";
+{ GlobalAllocator } :: import "../allocator";
+{ malloc, free } :: GlobalAllocator;
+open import "../fmt";
+{ Error, AnyError, Exception } :: import "../error";
+{ TcpStream } :: import "../net/tcp";
+{ IpAddr, SocketAddr } :: import "../net/addr";
+{ lookup_host } :: import "../net/dns";
+{ Url, UrlError } :: import "../url";
+{
+  HttpMethod, HttpHeader, HttpRequest, HttpResponse,
+  parse_response, http_status_text
+} :: import "./http.yo";
+
+// ============================================================================
+// HttpError
+// ============================================================================
+
+HttpError :: enum(
+  ConnectionFailed(msg: String),
+  InvalidUrl(msg: String),
+  Timeout,
+  TooManyRedirects,
+  UnsupportedScheme(scheme: String),
+  ResponseTooLarge,
+  Other(msg: String)
+);
+
+impl(HttpError, ToString(
+  to_string : (self ->
+    match(self,
+      .ConnectionFailed(msg) => `HTTP connection failed: ${msg}`,
+      .InvalidUrl(msg) => `Invalid URL: ${msg}`,
+      .Timeout => `HTTP request timed out`,
+      .TooManyRedirects => `Too many redirects`,
+      .UnsupportedScheme(scheme) => `Unsupported scheme: ${scheme}`,
+      .ResponseTooLarge => `Response too large`,
+      .Other(msg) => `HTTP error: ${msg}`
+    )
+  )
+));
+
+impl(HttpError, Error());
+
+export HttpError;
+
+// ============================================================================
+// FetchOptions
+// ============================================================================
+
+FetchOptions :: object(
+  method  : HttpMethod,
+  headers : ArrayList(HttpHeader),
+  body    : String
+);
+
+impl(FetchOptions,
+  new : (fn() -> Self)(
+    Self(
+      method: .GET,
+      headers: ArrayList(HttpHeader).new(),
+      body: ``
+    )
+  ),
+
+  with_method : (fn(self: Self, method: HttpMethod) -> Self)({
+    self.method = method;
+    self
+  }),
+
+  with_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
+  })
+);
+
+export FetchOptions;
+
+// ============================================================================
+// Internal helpers
+// ============================================================================
+
+// Find the position of \r\n\r\n (end of HTTP headers)
+_find_header_end :: (fn(data: ArrayList(u8)) -> usize)({
+  len := data.len();
+  cond(
+    (len < usize(4)) => { return usize(0); },
+    true => ()
+  );
+  i := usize(0);
+  limit := (len - usize(3));
+  while runtime((i < limit)), {
+    cond(
+      ((data.get(i).unwrap() == u8(13)) &&
+       ((data.get((i + usize(1))).unwrap() == u8(10)) &&
+        ((data.get((i + usize(2))).unwrap() == u8(13)) &&
+         (data.get((i + usize(3))).unwrap() == u8(10))))) => {
+        return i;
+      },
+      true => ()
+    );
+    i = (i + usize(1));
+  };
+  usize(0)
+});
+
+// Parse Content-Length from headers; returns -1 if not found.
+_find_content_length :: (fn(data: ArrayList(u8), header_end: usize) -> i32)({
+  // Build header string up to header_end
+  header_bytes := ArrayList(u8).new();
+  i := usize(0);
+  while runtime((i < header_end)), {
+    header_bytes.push(data.get(i).unwrap());
+    i = (i + usize(1));
+  };
+  header_str := String.from_bytes(header_bytes).to_lowercase();
+  match(header_str.index_of(`content-length:`),
+    .Some(pos) => {
+      val_start := (pos + usize(16));
+      // Find end of value by looking for \r\n after val_start
+      rest := header_str.substring(val_start, header_str.len());
+      match(rest.index_of(`\r\n`),
+        .Some(eol) => {
+          val_str := rest.substring(usize(0), eol).trim();
+          match(val_str.parse_i32(),
+            .Some(n) => n,
+            .None => i32(-1)
+          )
+        },
+        .None => {
+          val_str := rest.trim();
+          match(val_str.parse_i32(),
+            .Some(n) => n,
+            .None => i32(-1)
+          )
+        }
+      )
+    },
+    .None => i32(-1)
+  )
+});
+
+// ============================================================================
+// Internal: read full HTTP response from a TCP stream
+// ============================================================================
+
+_read_http_response :: (fn(stream: TcpStream, using(io : IO, exn : Exception)) -> String)({
+  buf_size := usize(8192);
+  buf := *(u8)(malloc(buf_size).unwrap());
+  result := ArrayList(u8).new();
+
+  // Read until connection closes or we've read the full response
+  done := false;
+  while runtime(!(done)), {
+    n := io.await(stream.read(buf, buf_size, using(io)));
+    cond(
+      (n <= i32(0)) => {
+        done = true;
+      },
+      true => {
+        i := usize(0);
+        while runtime((i < usize(n))), {
+          result.push((buf &+ i).*);
+          i = (i + usize(1));
+        };
+        // Check if we've received the full response by looking for
+        // Content-Length or end of chunked transfer
+        // For simplicity, check if the header section is complete
+        // and if Content-Length is satisfied
+        cond(
+          (result.len() > usize(4)) => {
+            // Check if we have a complete header section (\r\n\r\n)
+            header_end := _find_header_end(result);
+            cond(
+              (header_end > usize(0)) => {
+                // Check Content-Length
+                cl := _find_content_length(result, header_end);
+                cond(
+                  (cl >= i32(0)) => {
+                    body_start := (header_end + usize(4));
+                    body_len := (result.len() - body_start);
+                    cond(
+                      (body_len >= usize(cl)) => {
+                        done = true;
+                      },
+                      true => ()
+                    );
+                  },
+                  true => ()
+                );
+              },
+              true => ()
+            );
+          },
+          true => ()
+        );
+      }
+    );
+  };
+  free(.Some(*(void)(buf)));
+  String.from_bytes(result)
+});
+
+// ============================================================================
+// fetch — High-level async HTTP request (like JavaScript's fetch)
+// ============================================================================
+
+// Perform an HTTP request with custom options.
+//
+// Example:
+//   opts := FetchOptions.new().with_method(.POST).with_body(`{"key": "value"}`);
+//   resp := io.await(fetch_with(`http://example.com/api`, opts, using(io)));
+fetch_with :: (fn(url_str: String, opts: FetchOptions, using(io : IO)) ->
+  Impl(Future(HttpResponse, IO, Exception))
+)(
+  io.async((using(io : IO, exn : Exception)) => {
+    // Parse URL
+    url := Url.parse(url_str.as_str(), using(exn));
+
+    // Validate scheme
+    scheme := url.scheme();
+    is_http := (scheme == `http`);
+    is_https := (scheme == `https`);
+    cond(
+      (is_http || is_https) => (),
+      true => {
+        exn.throw(dyn HttpError.UnsupportedScheme(scheme));
+      }
+    );
+
+    // Extract host
+    host := match(url.host(),
+      .Some(h) => h,
+      .None => {
+        exn.throw(dyn HttpError.InvalidUrl(`missing host`));
+        `_` // unreachable
+      }
+    );
+
+    // Determine port (default: 80 for http, 443 for https)
+    port := match(url.port(),
+      .Some(p) => p,
+      .None => cond(
+        (scheme == `https`) => u16(443),
+        true => u16(80)
+      )
+    );
+
+    // Resolve hostname to IP
+    addrs := io.await(lookup_host(host, using(io)));
+    cond(
+      (addrs.len() == usize(0)) => {
+        exn.throw(dyn HttpError.ConnectionFailed(`DNS resolution failed for ${host}`));
+      },
+      true => ()
+    );
+    ip := addrs.get(usize(0)).unwrap();
+    addr := SocketAddr.new(ip, port);
+
+    // Connect
+    stream := io.await(TcpStream.connect(addr, using(io)));
+
+    // Build the request path (include query string if present)
+    req_path := url.path();
+    cond(
+      req_path.is_empty() => { req_path = `/`; },
+      true => ()
+    );
+    match(url.query(),
+      .Some(q) => { req_path = `${req_path}?${q}`; },
+      .None => ()
+    );
+
+    // Build HTTP request
+    req := HttpRequest.new(opts.method, req_path);
+    req.set_host(host);
+
+    // Add user-provided headers
+    hi := usize(0);
+    while runtime((hi < opts.headers.len())), {
+      h := opts.headers.get(hi).unwrap();
+      req.set_header(h.name, h.value);
+      hi = (hi + usize(1));
+    };
+
+    // Set Content-Length if body is provided
+    cond(
+      (!(opts.body.is_empty())) => {
+        req.set_body(opts.body);
+        req.set_header(`Content-Length`, `${opts.body.len()}`);
+      },
+      true => ()
+    );
+
+    // Set Connection: close to ensure the server closes after response
+    req.set_header(`Connection`, `close`);
+
+    // Send request
+    req_str := req.to_string();
+    io.await(stream.write_string(req_str, using(io)));
+
+    // Read response
+    raw_response := _read_http_response(stream, using(io, exn));
+
+    // Close connection
+    io.await(stream.close(using(io)));
+
+    // Parse response
+    match(parse_response(raw_response),
+      .Ok(resp) => resp,
+      .Err(e) => {
+        exn.throw(dyn HttpError.Other(e));
+        HttpResponse.new(i32(0), ``) // unreachable
+      }
+    )
+  })
+);
+
+export fetch_with;
+
+// Perform an HTTP GET request to the given URL string.
+// Returns the HttpResponse on success.
+//
+// Example:
+//   resp := io.await(fetch(`http://example.com`, using(io)));
+//   cond(resp.is_ok() => println(resp.body), true => println(`Error`));
+fetch :: (fn(url_str: String, using(io : IO)) ->
+  Impl(Future(HttpResponse, IO, Exception))
+)(
+  io.async((using(io : IO, exn : Exception)) => {
+    return io.await(fetch_with(url_str, FetchOptions.new(), using(io)));
+  })
+);
+
+export fetch;

package/std/http/index.yo

@@ -0,0 +1,22 @@
+// std/http - HTTP types, request/response builders, and async client.
+//
+// Example:
+//   { HttpRequest, HttpResponse, fetch } :: import "std/http";
+//   { Exception } :: import "std/error";
+//
+//   main :: (fn(using(io : IO)) -> unit)({
+//     given(exn) := Exception(throw : ((err) -> {
+//       println(err.message());
+//       escape ();
+//     }));
+//     resp := io.await(fetch(`http://example.com`, using(io)));
+//     println(resp.body);
+//   });
+
+_http :: import "./http.yo";
+_client :: import "./client.yo";
+
+export
+  ...(_http),
+  ...(_client)
+;

package/std/log/{log.yo → index.yo}

@@ -1,9 +1,9 @@
-// std/log/log.yo - Structured logging
+// std/log - Structured logging
 //
 // Provides a global logger with configurable level and output destination.
 //
 // Example:
-//   { info, warn, error, set_level, Level } :: import "std/log/log";
+//   { info, warn, error, set_level, Level } :: import "std/log";
 //
 //   set_level(.Info);
 //   info(String.from("application started"));

package/std/regex/{regex.yo → index.yo}

@@ -1,4 +1,4 @@
-// std/regex/regex.yo - Main Regex type
+// std/regex - Regular expression engine
 //
 // High-level regex API similar to JavaScript's RegExp.
 //

package/std/url/{url.yo → index.yo}

@@ -1,9 +1,9 @@
-// std/url/url.yo - URL parsing and formatting
+// std/url - URL parsing and formatting
 //
 // Parse, manipulate, and format URLs per RFC 3986 (simplified).
 //
 // Example:
-//   { Url, UrlError } :: import "std/url/url";
+//   { Url, UrlError } :: import "std/url";
 //
 //   url := Url.parse("https://example.com:8080/path?q=1#frag").unwrap();
 //   assert(url.scheme() == `https`);