inequality operation, better input parsing and example algorithm

Author: hexxt-git

examples/functions.bbee

@@ -0,0 +1,80 @@
+const checkPrime = func (i) => {
+    mut isPrime = 1,
+    
+    mut j = 1,
+    for (j = j + 1, j < i - 1 && isPrime) {
+        if ((i % j) == 0) {
+            isPrime = 0
+        }
+    },
+
+    isPrime
+},
+
+const nthPrime = func (n) => (
+    mut count = 0,
+    mut number = 2,
+    for (count < n) {
+        const check = checkPrime@number, 
+        if (check) {
+            count = count + 1
+        },
+        number = number + 1
+    },
+
+    number - 1
+),
+
+const nthFibonacci = func (n) => {
+    mut a = 1,
+    mut b = 1,
+
+    for (n = n - 1, n > 0) {
+        mut c = b,
+        b = a + b,
+        a = c
+    },
+
+    b
+},
+
+const nthTriangular = func (n) => {
+    n * (n + 1) / 2
+},
+
+const nthPentagonal = func (n) => {
+    n * (3 * n - 1) / 2
+},
+
+output "Welcome to my program\ntype exit to quit\n",
+
+mut user = 0,
+
+for (user != "exit") {
+    output "choose a sequence then n\n",
+    output "1 - Primes\n",
+    output "2 - Fibonacci\n",
+    output "3 - Triangular\n",
+    output "4 - Pentagonal\n",
+    user = input,
+
+    if(user == 1) {
+        output ("output:" + stringify (nthPrime@(input)))
+    } else {
+        if(user == 2) {
+            output ("output:" + stringify (nthFibonacci@(input)))
+        } else {
+            if(user == 3) {
+                output ("output:" + stringify (nthTriangular@(input)))
+            } else {
+                if(user == 4) {
+                    output ("output:" + stringify (nthPentagonal@(input)))
+                } else {
+                    output "Wrong operation"
+                }
+            }
+        }
+    },
+
+    output "\n ------------ \n"
+}

language/interpreter.ts

@@ -50,7 +50,10 @@ export default function interpret(
             const fn: Value = interpretHere(expression.left);
             if (typeof fn != "string" && typeof fn != "number") {
                 const values: Record<identifier, Variable> = {};
-                if(fn.inputs.length != expression.inputs.length) throw new Error("number of inputs to function call does not match number in declaration")
+                if (fn.inputs.length != expression.inputs.length)
+                    throw new Error(
+                        "number of inputs to function call does not match number in declaration"
+                    );
                 for (let [index, identifier] of Object.entries(fn.inputs)) {
                     values[identifier] = {
                         value: interpretHere(expression.inputs[Number(index)]),
@@ -180,6 +183,11 @@ export default function interpret(
                     const right = interpretHere(expression.right);
                     return left === right ? 1 : 0;
                 }
+                case "!=": {
+                    const left = interpretHere(expression.left);
+                    const right = interpretHere(expression.right);
+                    return left !== right ? 1 : 0;
+                }
                 case "&&": {
                     const left = interpretHere(expression.left);
                     const right = interpretHere(expression.right);
@@ -273,9 +281,10 @@ export default function interpret(
                     return Math.random();
                 case "input":
                     const input = prompt("input:") ?? "";
-                    const float = parseFloat(input);
-                    if (isNaN(float)) throw new Error("Input is not a number");
-                    return float;
+
+                    if (/^[+-]?[0-9]+(\.[0-9]+)?$/.test(input)) return parseFloat(input);
+
+                    return input;
                 default:
                     throw new Error("Unknown Macro: " + expression.identifier);
             }

language/lexer.ts

@@ -55,7 +55,7 @@ type TokenRegex = { kind: TokenKind; regex: RegExp };
 const TokenMap: Array<TokenRegex> = [
     {
         kind: TokenKind.unary,
-        regex: /^((!)|(floor)|(round)|(output)|(stringify))/,
+        regex: /^((!(?!=))|(floor)|(round)|(output)|(stringify))/,
     },
     {
         kind: TokenKind.additive,
@@ -79,7 +79,7 @@ const TokenMap: Array<TokenRegex> = [
     },
     {
         kind: TokenKind.comparative,
-        regex: /^((>=)|(<=)|(==)|>|<)/,
+        regex: /^((>=)|(<=)|(==)|(!=)|>|<)/,
     },
     {
         kind: TokenKind.logical,

language/parser.ts

@@ -113,6 +113,7 @@ export type Expression =
 
 export const PRECEDENCE: TokenKind[] = [
     // comma
+    // declaration
     // assignment
     // function declarations
     // Loops
@@ -219,6 +220,7 @@ export class Parser {
 
     private parseFunctionDeclaration(): Expression {
         if (this.top() && this.top().kind != TokenKind.func) return this.parseLoop();
+        
         this.pop(); // FUNC
         const inputs = this.parseFunctionInputs();
         if (this.top().kind !== TokenKind.arrow) this.pop(); // => optional