steel-lang-2 1.0.0 → 2.0.0

package/README.md

@@ -1,8 +1,8 @@
-[![npm](https://img.shields.io/npm/v/steel-lang-2)](https://www.npmjs.com/package/steel-lang-2)
+# Steel Language v2.0
 
-Steel is a simple, readable programming language designed to be easy to learn and intuitive to use.
+[![npm](https://img.shields.io/npm/v/steel-lang-2)](https://www.npmjs.com/package/steel-lang-2)
 
-It focuses on clean syntax, minimal complexity, and fast execution through a custom JavaScript interpreter.
+Steel is a simple, readable programming language designed to be easy to learn and intuitive to use. It focuses on clean syntax, minimal complexity, and fast execution through a custom JavaScript interpreter.
 
 ## Install
 
@@ -10,110 +10,100 @@ It focuses on clean syntax, minimal complexity, and fast execution through a cus
 npm install steel-lang-2
 ```
 
+## Features
 
+- **Variables**: `set x to 10`
+- **Output**: `say "Hello!"`
+- **Template Strings**: `` `Hello ${name}!` ``
+- **Conditionals**: `if / elseif / else / end`
+- **Loops**: `while / for / for each / repeat`
+- **Functions**: `define name as (params) ... return value end` with closures and recursion
+- **Arrays**: `[1, 2, 3]` with index access, `set arr[0] to val`
+- **Full Operators**: `+ - * / % > < >= <= == != and or not`
+- **Comments**: `// line comments`
+- **Booleans**: `true`, `false`, `null`
+- **Operator Precedence**: Proper precedence climbing (multiplication before addition, etc.)
 
+## Built-in Functions
 
+### Math
+`abs`, `round`, `floor`, `ceil`, `sqrt`, `pow`, `min`, `max`, `random`, `pi`, `e`
 
- Features:
-• 🧠 Human-readable syntax
-• ⚡ Lightweight interpreter (Node.js)
-• 🧱 Simple variable system
-• 🔁 Control flow (if statements, loops)
-• 💬 Built-in output (say)
-• 🎨 VS Code syntax highlighting support
-• 🔧 Easy to extend and modify
-
-
-
-
-Project Structure:
-
-steel-lang/
-├── src/ # Language engine
-│ ├── lexer.js
-│ ├── parser.js
-│ ├── interpreter.js
-│ ├── environment.js
-│ └── index.js
-├── examples/ # Example programs
-│ ├── hello.steel
-│ ├── logic.steel
-│ └── variables.steel
-├── stl/ # VS Code extension
-│ ├── syntaxes/
-│ ├── icons/
-│ └── package.json
-└── README.md
-
-
-
-
-
-🚀 Getting Started
-
-Clone the repository
-
-1. git clone https://github.com/theworker02/steel-lang.git
+### String
+`len`, `upper`, `lower`, `trim`, `substring`, `replace`, `split`, `join`, `contains`, `charAt`, `indexOf`, `startsWith`, `endsWith`, `repeat`, `padStart`, `padEnd`
 
-2. cd steel-lang
+### Array
+`push`, `pop`, `shift`, `unshift`, `reverse`, `sort`, `slice`, `includes`, `flat`, `range`
 
+### Type
+`type`, `isNumber`, `isString`, `isArray`, `toString`, `toNumber`
 
+### Misc
+`clock`, `sleep`, `input`
 
-Run a Steel program
-
-3. "node src/index.js examples/hello.steel"
+## Quick Start
 
+```bash
+git clone https://github.com/magnexis/Steel-lang.git
+cd Steel-lang
+node src/index.js examples/hello.steel
+```
 
-🧪 Example:
+## Example
 
-set x to 10
+```steel
+// Variables and types
+set name to "Steel"
+set version to 2
 
-if x > 5 then
-say "Steel is working!"
+// Functions with recursion
+define factorial as (n)
+  if n <= 1 then
+    return 1
+  end
+  return n * factorial(n - 1)
 end
 
+say factorial(10)  // 3628800
 
-https://steel-lang.base44.app
-
-
-🧩 VS Code Extension:
-
-Steel includes a custom VS Code extension for syntax highlighting.
-
-Run locally: “cd stl”
-
-Then open the folder in VS code and press: F5
-
-
-🎯 Goals:
-
-• Keep syntax simple and readable
-• Build a fully custom language ecosystem
-• Add functions, modules, and advanced features
-• Expand tooling (CLI, debugger, autocomplete)
-
-
-https://steel-lang.base44.app
-
-
-🛠️ Future Plans:
-
-• CLI command (steel run file.steel)
-• Error handling improvements
-• Function system
-• Package manager (maybe 👀)
-• Full VS Code integration (IntelliSense)
-
-
-🤝 Contributing:
+// Arrays and loops
+set nums to [1, 2, 3, 4, 5]
+for each n in nums
+  say n * n
+end
 
-Pull requests are welcome. This project is actively evolving and is considered to me still a work in progress. A lot has to be done honestly.
+// Higher-order patterns
+define sum as (arr)
+  set total to 0
+  for each val in arr
+    set total to total + val
+  end
+  return total
+end
 
-License: MIT License
+say sum(range(1, 101))  // 5050
+```
 
-Author: theworker02
+## Project Structure
 
-⚙️ Status:
+```
+steel-lang/
+├── src/           # Language engine
+│   ├── lexer.js       # Tokenizer
+│   ├── parser.js      # Recursive descent parser with precedence climbing
+│   ├── interpreter.js # Tree-walking interpreter
+│   ├── environment.js # Scope, built-ins, function closures
+│   └── index.js       # CLI entry point
+├── examples/      # Example programs
+│   ├── hello.steel
+│   ├── logic.steel
+│   ├── variables.steel
+│   ├── features-demo.steel
+│   ├── control-flow.steel
+│   └── functions-arrays.steel
+└── stl/           # VS Code extension
+```
 
-🚧 Early Development/Work in progress, but fully functional
+## License
 
+MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "icon": "icons/steel.png",
   "name": "steel-lang-2",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "files": [
     "src/",
     "icons/"

package/src/environment.js

@@ -1,35 +1,192 @@
 class Environment {
-
-  constructor() {
-
+  constructor(parent = null) {
     this.variables = {};
-
+    this.parent = parent;
   }
 
-
-
   set(name, value) {
-
     this.variables[name] = value;
-
   }
 
-
-
   get(name) {
-
-    if (!(name in this.variables)) {
-
-      throw new Error(`Variable "${name}" is not defined`);
-
+    if (name in this.variables) {
+      return this.variables[name];
+    }
+    if (this.parent) {
+      return this.parent.get(name);
     }
+    throw new Error(`Variable "${name}" is not defined`);
+  }
 
-    return this.variables[name];
+  has(name) {
+    if (name in this.variables) return true;
+    if (this.parent) return this.parent.has(name);
+    return false;
+  }
 
+  // Function storage
+  defineFunction(name, params, body, closureEnv) {
+    this.variables[name] = {
+      type: 'function',
+      params,
+      body,
+      closure: closureEnv,
+    };
   }
 
-}
+  isFunction(name) {
+    const val = this.has(name) ? this.get(name) : undefined;
+    return val && val.type === 'function';
+  }
 
+  callFunction(name, args) {
+    const fn = this.get(name);
+    if (!fn || fn.type !== 'function') {
+      throw new Error(`"${name}" is not a function`);
+    }
+    const fnEnv = new Environment(fn.closure);
+    for (let i = 0; i < fn.params.length; i++) {
+      fnEnv.set(fn.params[i], args[i] !== undefined ? args[i] : null);
+    }
+    return { env: fnEnv, body: fn.body };
+  }
 
+  // Built-in functions
+  static createGlobal() {
+    const env = new Environment();
+
+    // Math functions
+    env.set('abs', { type: 'builtin', fn: Math.abs, name: 'abs' });
+    env.set('round', { type: 'builtin', fn: (n) => Math.round(n), name: 'round' });
+    env.set('floor', { type: 'builtin', fn: Math.floor, name: 'floor' });
+    env.set('ceil', { type: 'builtin', fn: Math.ceil, name: 'ceil' });
+    env.set('sqrt', { type: 'builtin', fn: Math.sqrt, name: 'sqrt' });
+    env.set('pow', { type: 'builtin', fn: (a, b) => Math.pow(a, b), name: 'pow' });
+    env.set('min', { type: 'builtin', fn: Math.min, name: 'min' });
+    env.set('max', { type: 'builtin', fn: Math.max, name: 'max' });
+    env.set('random', { type: 'builtin', fn: () => Math.random(), name: 'random' });
+    env.set('pi', Math.PI);
+    env.set('e', Math.E);
+
+    // String functions
+    env.set('len', { type: 'builtin', fn: (v) => {
+      if (Array.isArray(v)) return v.length;
+      if (typeof v === 'string') return v.length;
+      return String(v).length;
+    }, name: 'len' });
+    env.set('upper', { type: 'builtin', fn: (s) => String(s).toUpperCase(), name: 'upper' });
+    env.set('lower', { type: 'builtin', fn: (s) => String(s).toLowerCase(), name: 'lower' });
+    env.set('trim', { type: 'builtin', fn: (s) => String(s).trim(), name: 'trim' });
+    env.set('substring', { type: 'builtin', fn: (s, start, end) => {
+      if (end !== undefined) return String(s).substring(start, end);
+      return String(s).substring(start);
+    }, name: 'substring' });
+    env.set('replace', { type: 'builtin', fn: (s, from, to) => String(s).replaceAll(from, to), name: 'replace' });
+    env.set('split', { type: 'builtin', fn: (s, sep) => String(s).split(sep), name: 'split' });
+    env.set('join', { type: 'builtin', fn: (arr, sep) => Array.isArray(arr) ? arr.join(sep) : String(arr), name: 'join' });
+    env.set('contains', { type: 'builtin', fn: (s, sub) => String(s).includes(sub), name: 'contains' });
+    env.set('charAt', { type: 'builtin', fn: (s, i) => String(s).charAt(i), name: 'charAt' });
+    env.set('indexOf', { type: 'builtin', fn: (s, sub) => String(s).indexOf(sub), name: 'indexOf' });
+    env.set('startsWith', { type: 'builtin', fn: (s, prefix) => String(s).startsWith(prefix), name: 'startsWith' });
+    env.set('endsWith', { type: 'builtin', fn: (s, suffix) => String(s).endsWith(suffix), name: 'endsWith' });
+    env.set('repeat', { type: 'builtin', fn: (s, n) => String(s).repeat(n), name: 'repeat' });
+    env.set('padStart', { type: 'builtin', fn: (s, n, ch) => String(s).padStart(n, ch || ' '), name: 'padStart' });
+    env.set('padEnd', { type: 'builtin', fn: (s, n, ch) => String(s).padEnd(n, ch || ' '), name: 'padEnd' });
+
+    // Type checking
+    env.set('type', { type: 'builtin', fn: (v) => {
+      if (v === null) return 'null';
+      if (Array.isArray(v)) return 'array';
+      if (typeof v === 'number') return 'number';
+      if (typeof v === 'string') return 'string';
+      if (typeof v === 'boolean') return 'boolean';
+      return 'unknown';
+    }, name: 'type' });
+    env.set('isNumber', { type: 'builtin', fn: (v) => typeof v === 'number', name: 'isNumber' });
+    env.set('isString', { type: 'builtin', fn: (v) => typeof v === 'string', name: 'isString' });
+    env.set('isArray', { type: 'builtin', fn: (v) => Array.isArray(v), name: 'isArray' });
+    env.set('toString', { type: 'builtin', fn: (v) => String(v), name: 'toString' });
+    env.set('toNumber', { type: 'builtin', fn: (v) => Number(v), name: 'toNumber' });
+
+    // Array functions
+    env.set('push', { type: 'builtin', fn: (arr, item) => {
+      if (!Array.isArray(arr)) throw new Error('push() requires an array');
+      arr.push(item);
+      return arr;
+    }, name: 'push' });
+    env.set('pop', { type: 'builtin', fn: (arr) => {
+      if (!Array.isArray(arr)) throw new Error('pop() requires an array');
+      return arr.pop();
+    }, name: 'pop' });
+    env.set('shift', { type: 'builtin', fn: (arr) => {
+      if (!Array.isArray(arr)) throw new Error('shift() requires an array');
+      return arr.shift();
+    }, name: 'shift' });
+    env.set('unshift', { type: 'builtin', fn: (arr, item) => {
+      if (!Array.isArray(arr)) throw new Error('unshift() requires an array');
+      arr.unshift(item);
+      return arr;
+    }, name: 'unshift' });
+    env.set('reverse', { type: 'builtin', fn: (arr) => {
+      if (!Array.isArray(arr)) throw new Error('reverse() requires an array');
+      return [...arr].reverse();
+    }, name: 'reverse' });
+    env.set('sort', { type: 'builtin', fn: (arr) => {
+      if (!Array.isArray(arr)) throw new Error('sort() requires an array');
+      return [...arr].sort((a, b) => a - b);
+    }, name: 'sort' });
+    env.set('slice', { type: 'builtin', fn: (arr, start, end) => {
+      if (!Array.isArray(arr)) throw new Error('slice() requires an array');
+      if (end !== undefined) return arr.slice(start, end);
+      return arr.slice(start);
+    }, name: 'slice' });
+    env.set('indexOf_arr', { type: 'builtin', fn: (arr, item) => {
+      if (!Array.isArray(arr)) throw new Error('indexOf requires an array');
+      return arr.indexOf(item);
+    }, name: 'indexOf_arr' });
+    env.set('includes', { type: 'builtin', fn: (arr, item) => {
+      if (!Array.isArray(arr)) throw new Error('includes() requires an array');
+      return arr.includes(item);
+    }, name: 'includes' });
+    env.set('flat', { type: 'builtin', fn: (arr, depth) => {
+      if (!Array.isArray(arr)) throw new Error('flat() requires an array');
+      return arr.flat(depth);
+    }, name: 'flat' });
+    env.set('range', { type: 'builtin', fn: (start, end, step) => {
+      step = step || 1;
+      const result = [];
+      if (step > 0) {
+        for (let i = start; i < end; i += step) result.push(i);
+      } else {
+        for (let i = start; i > end; i += step) result.push(i);
+      }
+      return result;
+    }, name: 'range' });
+
+    // I/O
+    env.set('input', { type: 'builtin', fn: (prompt) => {
+      if (typeof require !== 'undefined') {
+        const readline = require('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+          rl.question(prompt || '', (answer) => {
+            rl.close();
+            resolve(answer);
+          });
+        });
+      }
+      return null;
+    }, name: 'input' });
+
+    // Misc
+    env.set('clock', { type: 'builtin', fn: () => Date.now(), name: 'clock' });
+    env.set('sleep', { type: 'builtin', fn: (ms) => {
+      const end = Date.now() + ms;
+      while (Date.now() < end) {} // busy wait
+    }, name: 'sleep' });
+
+    return env;
+  }
+}
 
 module.exports = Environment;

package/src/index.js

@@ -1,49 +1,43 @@
 const fs = require('fs');
-
 const { tokenize } = require('./lexer');
-
 const { parse } = require('./parser');
-
 const { interpret } = require('./interpreter');
-
 const Environment = require('./environment');
 
-
-
 const file = process.argv[2];
 
-
-
 if (!file) {
-
+  console.log("Steel Language Interpreter v2.0.0");
   console.log("Usage: node src/index.js <file.steel>");
-
+  console.log("");
+  console.log("Features:");
+  console.log("  Variables:    set x to 10");
+  console.log("  Output:       say \"Hello!\"");
+  console.log("  Conditionals: if x > 5 then ... elseif x > 3 then ... else ... end");
+  console.log("  Loops:        while x > 0 do ... end");
+  console.log("  For loops:    for i to 10 ... end | for each item in arr ... end");
+  console.log("  Repeat:       repeat 5 times ... end");
+  console.log("  Functions:    define greet as (name) ... return \"Hello \" + name end");
+  console.log("  Arrays:       set nums to [1, 2, 3, 4, 5]");
+  console.log("  Operators:    + - * / % > < >= <= == != and or not");
+  console.log("  Comments:     // this is a comment");
+  console.log("  Templates:    say `Hello ${name}!`");
+  console.log("  Booleans:     true, false, null");
+  console.log("  Built-ins:    abs, round, floor, ceil, sqrt, pow, min, max, random");
+  console.log("  Strings:      len, upper, lower, trim, substring, replace, split, join");
+  console.log("  Arrays:       push, pop, shift, unshift, reverse, sort, slice, includes");
+  console.log("  Types:        type, isNumber, isString, isArray, toString, toNumber");
+  console.log("  Misc:         pi, e, clock, sleep, input, range");
   process.exit(1);
-
 }
 
-
-
 try {
-
   const code = fs.readFileSync(file, 'utf-8');
-
-
-
   const tokens = tokenize(code);
-
   const ast = parse(tokens);
-
-
-
-  const env = new Environment();
-
-
-
+  const env = Environment.createGlobal();
   interpret(ast, env);
-
 } catch (err) {
-
-  console.error("Error:", err.message);
-
+  console.error("Error: " + err.message);
+  process.exit(1);
 }