@shd101wyy/yo 0.1.14 → 0.1.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",
@@ -48,6 +48,8 @@
   },
   "dependencies": {
     "markdown_yo": "0.0.4",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
     "yargs": "^17.7.2"
   },
   "devDependencies": {

package/scripts/build-site.ts

@@ -20,18 +20,19 @@ import * as fs from "fs";
 import * as path from "path";
 import { createRenderer } from "markdown_yo";
 import type { MarkdownRenderer } from "markdown_yo";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 
 const ROOT = path.resolve(import.meta.dir, "..");
 const GITHUB_REPO = "https://github.com/shd101wyy/Yo";
 
 // Detect the latest release tag for stable links.
 // Falls back to "main" if no tags exist or git fails.
-function getLatestTag(): string {
+export function getLatestTag(rootDir: string = ROOT): string {
   try {
-    const result = execSync("git describe --tags --abbrev=0 2>/dev/null", {
-      cwd: ROOT,
+    const result = execFileSync("git", ["describe", "--tags", "--abbrev=0"], {
+      cwd: rootDir,
       encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 5000,
     }).trim();
     return result || "main";
@@ -43,6 +44,16 @@ function getLatestTag(): string {
 const GITHUB_REF = getLatestTag();
 const GITHUB_BLOB = `${GITHUB_REPO}/blob/${GITHUB_REF}`;
 
+export function getStdDocCommand(rootDir: string = ROOT): {
+  command: string;
+  args: string[];
+} {
+  return {
+    command: "node",
+    args: [path.join(rootDir, "out", "cjs", "yo-cli.cjs"), "doc", "std/"],
+  };
+}
+
 // ── Parse args ───────────────────────────────────────────────────────
 
 let outputDir = path.join(ROOT, "site");
@@ -399,7 +410,7 @@ function injectHomeLinks(stdDir: string): void {
 
 // ── Main ─────────────────────────────────────────────────────────────
 
-async function main(): Promise<void> {
+export async function main(): Promise<void> {
   console.log("Building documentation site...");
   console.log(`  Output: ${outputDir}`);
 
@@ -449,12 +460,16 @@ async function main(): Promise<void> {
   const stdOutputDir = path.join(outputDir, "std");
 
   try {
-    const yoCli = path.join(ROOT, "yo-cli");
-    execSync(`${yoCli} doc std/ --output "${stdOutputDir}"`, {
-      cwd: ROOT,
-      stdio: ["pipe", "pipe", "inherit"],
-      timeout: 120_000,
-    });
+    const stdDocCommand = getStdDocCommand();
+    execFileSync(
+      stdDocCommand.command,
+      [...stdDocCommand.args, "--output", stdOutputDir],
+      {
+        cwd: ROOT,
+        stdio: ["ignore", "inherit", "inherit"],
+        timeout: 600_000,
+      }
+    );
     console.log("  ✓ Standard library docs generated");
   } catch (err) {
     console.error(
@@ -492,7 +507,9 @@ function getTotalSize(dir: string): number {
   return Math.round(total / 1024);
 }
 
-main().catch((err) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}

package/scripts/check-liburing.js

@@ -9,9 +9,9 @@ const fs = require("fs");
 function checkLiburing() {
   const platform = os.platform();
 
-  // Only check on Linux
+  // Only check on Linux. Other platforms don't use io_uring, so keep postinstall
+  // quiet instead of printing a Linux-specific note.
   if (platform !== "linux") {
-    console.log("ℹ️  Async I/O with io_uring is only supported on Linux.");
     return;
   }
 

package/std/imm/list.yo

@@ -0,0 +1,254 @@
+//! Persistent immutable singly-linked list with O(1) prepend, head, and tail.
+//!
+//! `List(T)` is a cons list backed by `atomic object` nodes for thread-safe
+//! structural sharing. Multiple lists can share tails with no copying.
+//!
+//! All elements must implement `Send` to guarantee thread safety.
+//!
+//! # Examples
+//!
+//! ```rust
+//! { List } :: import "std/imm/list";
+//!
+//! xs := List(i32).new();
+//! xs = xs.prepend(i32(3)).prepend(i32(2)).prepend(i32(1));
+//! assert((xs.head().unwrap() == i32(1)), "head is 1");
+//! assert((xs.len() == usize(3)), "length is 3");
+//! ```
+
+{ GlobalAllocator } :: import "../allocator.yo";
+{ malloc, free } :: GlobalAllocator;
+{ memcpy } :: import "../libc/string.yo";
+
+/// Internal cons cell — atomic object for thread-safe structural sharing.
+ListNode :: (fn(comptime(T) : Type, where(T <: Send)) -> comptime(Type))(
+  atomic object(
+    _value : T,
+    _next : Option(Self)
+  )
+);
+
+// Manual Acyclic impl — ListNode is self-referential, so auto-derivation skips it.
+// This is safe because ListNode is immutable: all operations create new nodes and never
+// mutate existing ones, making it impossible to form cycles at runtime.
+impl(forall(T : Type), where(T <: Send), ListNode(T), Acyclic());
+
+/// Persistent immutable singly-linked list.
+///
+/// A value-type wrapper around an optional chain of `ListNode` atomic objects.
+/// Cheap to copy (just a pointer + length). All "modification" operations
+/// return a new `List` that shares structure with the original.
+List :: (fn(comptime(T) : Type, where(T <: Send)) -> comptime(Type))(
+  struct(
+    _head : Option(ListNode(T)),
+    _len : usize
+  )
+);
+
+impl(forall(T : Type), where(T <: Send), List(T),
+  /// Create an empty list.
+  new : (fn() -> Self)(
+    Self(_head: .None, _len: usize(0))
+  ),
+
+  /// Return the number of elements.
+  len : (fn(self : Self) -> usize)(
+    self._len
+  ),
+
+  /// Return `true` if the list is empty.
+  is_empty : (fn(self : Self) -> bool)(
+    (self._len == usize(0))
+  ),
+
+  /// Return a new list with `value` at the front. O(1).
+  prepend : (fn(self : Self, value : T) -> Self)(
+    Self(
+      _head: .Some(ListNode(T)(_value: value, _next: self._head)),
+      _len: (self._len + usize(1))
+    )
+  ),
+
+  /// Return the first element, or `.None` if empty. O(1).
+  head : (fn(self : Self) -> Option(T))(
+    match(self._head,
+      .Some(node) => .Some(node._value),
+      .None => .None
+    )
+  ),
+
+  /// Return a new list without the first element. O(1).
+  /// Returns an empty list if already empty.
+  tail : (fn(self : Self) -> Self)(
+    match(self._head,
+      .Some(node) => Self(_head: node._next, _len: (self._len - usize(1))),
+      .None => self
+    )
+  ),
+
+  /// Access element at `index`. O(n).
+  /// Returns `.None` if index is out of bounds.
+  get : (fn(self : Self, index : usize) -> Option(T))({
+    if((index >= self._len), {
+      return .None;
+    });
+    (current : Option(ListNode(T))) = self._head;
+    (i : usize) = usize(0);
+    while runtime(true), {
+      match(current,
+        .Some(node) => {
+          if((i == index), {
+            return .Some(node._value);
+          });
+          current = node._next;
+          i = (i + usize(1));
+        },
+        .None => {
+          return .None;
+        }
+      );
+    };
+    .None
+  }),
+
+  /// Return a new list with elements in reverse order. O(n).
+  reverse : (fn(self : Self) -> Self)({
+    (result : Self) = Self.new();
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      result = result.prepend(node._value);
+      current = node._next;
+    };
+    result
+  }),
+
+  /// Concatenate two lists. O(n) where n = self.len().
+  /// The resulting list contains all elements of `self` followed by `other`.
+  concat : (fn(self : Self, other : Self) -> Self)({
+    reversed := self.reverse();
+    (result : Self) = other;
+    (current : Option(ListNode(T))) = reversed._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      result = result.prepend(node._value);
+      current = node._next;
+    };
+    result
+  }),
+
+  /// Apply a function to each element, producing a new list. O(n).
+  map : (fn(forall(U : Type), self : Self, f : Impl(Fn(a : T) -> U), where(U <: Send)) -> List(U))({
+    (result : List(U)) = List(U).new();
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      result = result.prepend(f(node._value));
+      current = node._next;
+    };
+    result.reverse()
+  }),
+
+  /// Keep only elements satisfying the predicate. O(n).
+  filter : (fn(self : Self, f : Impl(Fn(a : T) -> bool)) -> Self)({
+    (result : Self) = Self.new();
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      if(f(node._value), {
+        result = result.prepend(node._value);
+      });
+      current = node._next;
+    };
+    result.reverse()
+  }),
+
+  /// Left fold over the list. O(n).
+  fold : (fn(forall(U : Type), self : Self, init : U, f : Impl(Fn(acc : U, item : T) -> U)) -> U)({
+    (acc : U) = init;
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      acc = f(acc, node._value);
+      current = node._next;
+    };
+    acc
+  }),
+
+  /// Execute a function for each element. O(n).
+  for_each : (fn(self : Self, f : Impl(Fn(a : T) -> unit)) -> unit)({
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(current.is_some()), {
+      (node : ListNode(T)) = current.unwrap();
+      f(node._value);
+      current = node._next;
+    };
+  }),
+
+  /// Check if the list contains a value. O(n).
+  /// Requires T to implement Eq.
+  contains : (fn(self : Self, value : T, where(T <: Eq(T))) -> bool)({
+    (current : Option(ListNode(T))) = self._head;
+    while runtime(true), {
+      match(current,
+        .Some(node) => {
+          if((node._value == value), {
+            return true;
+          });
+          current = node._next;
+        },
+        .None => {
+          return false;
+        }
+      );
+    };
+    false
+  }),
+
+  /// Build a list from a slice. O(n).
+  from_slice : (fn(s : Slice(T)) -> Self)({
+    (result : Self) = Self.new();
+    (i : usize) = s.len();
+    while ((i > usize(0))), {
+      i = (i - usize(1));
+      result = result.prepend(s(i));
+    };
+    result
+  })
+);
+
+/// Equality: two lists are equal if they have the same length and elements.
+impl(forall(T : Type), where(T <: (Send, Eq(T))), List(T), Eq(List(T))(
+  (==) : (fn(lhs : Self, rhs : Self) -> bool)({
+    if((lhs._len != rhs._len), {
+      return false;
+    });
+    (l : Option(ListNode(T))) = lhs._head;
+    (r : Option(ListNode(T))) = rhs._head;
+    while runtime(true), {
+      match(l,
+        .Some(ln) => match(r,
+          .Some(rn) => {
+            if((ln._value != rn._value), {
+              return false;
+            });
+            l = ln._next;
+            r = rn._next;
+          },
+          .None => {
+            return false;
+          }
+        ),
+        .None => {
+          return true;
+        }
+      );
+    };
+    true
+  })
+));
+
+export
+  List,
+  ListNode
+;