@shd101wyy/yo 0.1.8 → 0.1.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",
@@ -34,7 +34,7 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "postinstall": "node scripts/check-liburing.js",
+    "postinstall": "node scripts/print-welcome.js && node scripts/check-liburing.js",
     "prepare": "husky"
   },
   "lint-staged": {

package/scripts/print-welcome.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const fs = require("fs");
+const path = require("path");
+
+function printWelcome() {
+  // Find package.json - could be in the installed package or a dependency
+  let packageJsonPath;
+
+  // Try to find the @shd101wyy/yo package.json
+  const possiblePaths = [path.join(__dirname, "..", "package.json")];
+
+  // Also try to resolve from node_modules (when installed as a dependency)
+  try {
+    possiblePaths.push(require.resolve("@shd101wyy/yo/package.json"));
+  } catch (e) {
+    // Module not found, that's okay - we'll use the local path
+  }
+
+  for (const pkgPath of possiblePaths) {
+    try {
+      if (fs.existsSync(pkgPath)) {
+        packageJsonPath = pkgPath;
+        break;
+      }
+    } catch (e) {
+      // Continue to next path
+    }
+  }
+
+  if (!packageJsonPath || !fs.existsSync(packageJsonPath)) {
+    return; // Silently fail if we can't find the package.json
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    const version = packageJson.version;
+
+    if (!version) {
+      return;
+    }
+
+    console.log("");
+    console.log("👋 Welcome to Yo!");
+    console.log(`   You have installed @shd101wyy/yo@${version}`);
+    console.log("");
+  } catch (e) {
+    // Silently fail - don't want to break installation
+  }
+}
+
+printWelcome();

package/std/fmt/to_string.yo

@@ -243,4 +243,141 @@ impl(rune, ToString(
   })
 ));
 
-// TODO: Array to_string implementation?
+// TODO: Array to_string implementation?
+
+// --- derive_rule for ToString ---
+// Local helpers (not exported from prelude, so defined locally)
+__ts_s2 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string) -> comptime(comptime_string))((a + b));
+__ts_s3 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string) -> comptime(comptime_string))(
+  ((a + b) + c)
+);
+__ts_s4 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string, comptime(d) : comptime_string) -> comptime(comptime_string))(
+  (((a + b) + c) + d)
+);
+__ts_s5 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string, comptime(d) : comptime_string, comptime(e) : comptime_string) -> comptime(comptime_string))(
+  ((((a + b) + c) + d) + e)
+);
+__ts_fold_range :: (fn(
+  comptime(n) : usize,
+  comptime(init) : comptime_string,
+  comptime(f) : (fn(comptime(acc) : comptime_string, comptime(i) : usize) -> comptime(comptime_string))
+) -> comptime(comptime_string))(
+  cond(
+    (n == usize(0)) => init,
+    (n == usize(1)) => f(init, usize(0)),
+    true => f(recur((n - usize(1)), init, f), (n - usize(1)))
+  )
+);
+
+// Helper: join string parts with + operator, left-to-right parenthesized
+__derive_join_plus :: (fn(comptime(parts) : comptime_string, comptime(new_part) : comptime_string) -> comptime(comptime_string))(
+  cond(
+    (parts == "") => new_part,
+    true => __ts_s5("(", parts, " + ", new_part, ")")
+  )
+);
+
+__derive_tostring :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(trait_params) : ComptimeList(Expr)) -> comptime(Expr))(
+  {
+    type_name :: Type.to_comptime_string(T);
+    info :: Type.get_info(T);
+    cond(
+      info.is_struct() => {
+        fields :: Type.get_struct_fields(T);
+        fc :: fields.len();
+        cond(
+          (fc == 0) => {
+            label :: __ts_s3("String.from(\"", type_name, "()\")");
+            ctx.make_impl(quote(
+              ToString(
+                to_string : ((self) -> #(label.to_expr()))
+              )
+            ))
+          },
+          true => {
+            body :: __ts_fold_range(fc, __ts_s3("String.from(\"", type_name, "(\")" ),
+              (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))(
+                {
+                  fname :: fields.get(fi).name;
+                  with_sep :: cond(
+                    (fi == 0) => a,
+                    true => __derive_join_plus(a, "String.from(\", \")")
+                  );
+                  __derive_join_plus(with_sep, __ts_s3("(&(self.*.", fname, ")).to_string()"))
+                }
+              )
+            );
+            full_body :: __derive_join_plus(body, "String.from(\")\")");
+            ctx.make_impl(quote(
+              ToString(
+                to_string : ((self) -> #(full_body.to_expr()))
+              )
+            ))
+          }
+        )
+      },
+      info.is_enum() => {
+        variants :: Type.get_enum_variants(T);
+        vc :: variants.len();
+        ts_branches :: __ts_fold_range(vc, "",
+          (fn(comptime(acc) : comptime_string, comptime(vi) : usize) -> comptime(comptime_string))(
+            {
+              v :: variants.get(vi);
+              branch :: cond(
+                (v.fields.len() == 0) =>
+                  __ts_s5(".", v.name, " => String.from(\"", type_name, __ts_s3(".", v.name, "\")")),
+                true => {
+                  bindings :: __ts_fold_range(v.fields.len(), "",
+                    (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))(
+                      {
+                        fname :: v.fields.get(fi).name;
+                        cond(
+                          (a == "") => __ts_s2("__v_", fname),
+                          true => __ts_s3(a, ", __v_", fname)
+                        )
+                      }
+                    )
+                  );
+                  body :: __ts_fold_range(v.fields.len(),
+                    __ts_s5("String.from(\"", type_name, ".", v.name, "(\")" ),
+                    (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))(
+                      {
+                        fname :: v.fields.get(fi).name;
+                        with_sep :: cond(
+                          (fi == 0) => a,
+                          true => __derive_join_plus(a, "String.from(\", \")")
+                        );
+                        __derive_join_plus(with_sep, __ts_s3("(&(__v_", fname, ")).to_string()"))
+                      }
+                    )
+                  );
+                  full_body :: __derive_join_plus(body, "String.from(\")\")");
+                  __ts_s4(".", v.name, __ts_s3("(", bindings, ") => "), full_body)
+                }
+              );
+              cond(
+                (acc == "") => branch,
+                true => __ts_s3(acc, ",\n    ", branch)
+              )
+            }
+          )
+        );
+        match_body :: __ts_s3("match(self.*,\n    ", ts_branches, "\n  )");
+        ctx.make_impl(quote(
+          ToString(
+            to_string : ((self) -> #(match_body.to_expr()))
+          )
+        ))
+      },
+      true => {
+        label :: __ts_s3("String.from(\"", type_name, "\")");
+        ctx.make_impl(quote(
+          ToString(
+            to_string : ((self) -> #(label.to_expr()))
+          )
+        ))
+      }
+    )
+  }
+);
+derive_rule(ToString, __derive_tostring);