hispano-lang 2.0.0 → 2.1.1

package/README.md

@@ -341,6 +341,41 @@ variable duplicar = funcion(x) {
 mostrar duplicar(5)  // 10
 ```
 
+#### Funciones Flecha
+
+Sintaxis concisa para funciones anónimas:
+
+```
+// Un parámetro (sin paréntesis)
+variable doble = x => x * 2
+
+// Múltiples parámetros
+variable suma = (a, b) => a + b
+
+// Sin parámetros
+variable saludar = () => "Hola mundo"
+
+// Con bloque de código
+variable factorial = n => {
+    si (n <= 1) { retornar 1 }
+    retornar n * factorial(n - 1)
+}
+
+mostrar doble(5)       // 10
+mostrar suma(3, 4)     // 7
+mostrar factorial(5)   // 120
+```
+
+Funciones flecha son ideales para callbacks:
+
+```
+variable numeros = [1, 2, 3, 4, 5]
+
+numeros.mapear(x => x * 2)           // [2, 4, 6, 8, 10]
+numeros.filtrar(x => x > 2)          // [3, 4, 5]
+numeros.reducir((a, b) => a + b, 0)  // 15
+```
+
 #### Funciones como Parámetros
 
 ```

package/dist/evaluator.js

@@ -23,7 +23,7 @@ class Evaluator {
         this.execute(statement);
       }
     } catch (error) {
-      throw new Error(`Error de ejecución: ${error.message}`);
+      throw new Error(error.message);
     }
 
     return this.output;
@@ -135,7 +135,6 @@ class Evaluator {
     const value = this.evaluateExpression(statement.expression);
     const output = this.stringify(value);
     this.output.push(output);
-    console.log(output);
   }
 
   /**
@@ -307,6 +306,28 @@ class Evaluator {
     }
   }
 
+  /**
+   * Executes a function body (handles both block and arrow expression bodies)
+   * @param {Object} func - Function object with body and isArrowExpression flag
+   * @returns {any} Result of the function execution
+   */
+  executeFunctionBody(func) {
+    if (func.isArrowExpression) {
+      return this.evaluateExpression(func.body);
+    }
+    try {
+      for (const statement of func.body) {
+        this.execute(statement);
+      }
+      return null;
+    } catch (returnValue) {
+      if (returnValue instanceof ReturnException) {
+        return returnValue.value;
+      }
+      throw returnValue;
+    }
+  }
+
   /**
    * Executes an expression statement
    * @param {Object} statement - Expression statement
@@ -339,6 +360,15 @@ class Evaluator {
           body: expression.body,
         };
 
+      case "ArrowFunction":
+        return {
+          type: "Function",
+          name: null,
+          parameters: expression.parameters,
+          body: expression.body,
+          isArrowExpression: expression.isExpression,
+        };
+
       case "Assign":
         const value = this.evaluateExpression(expression.value);
         this.environment.assign(expression.name, value);
@@ -622,6 +652,10 @@ class Evaluator {
     const previous = this.environment;
     try {
       this.environment = environment;
+      // Arrow functions with expression body return the expression directly
+      if (callee.isArrowExpression) {
+        return this.evaluateExpression(callee.body);
+      }
       this.executeBlock(callee.body);
       return null;
     } catch (returnValue) {
@@ -856,7 +890,7 @@ class Evaluator {
           const previousEnv = this.environment;
           this.environment = callbackEnv;
           try {
-            this.executeBlock(callback.body);
+            this.executeFunctionBody(callback);
           } finally {
             this.environment = previousEnv;
           }
@@ -884,14 +918,9 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = filterEnv;
           try {
-            this.executeBlock(filterCallback.body);
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              if (this.isTruthy(returnValue.value)) {
-                filteredArray.push(array[i]);
-              }
-            } else {
-              throw returnValue;
+            const result = this.executeFunctionBody(filterCallback);
+            if (this.isTruthy(result)) {
+              filteredArray.push(array[i]);
             }
           } finally {
             this.environment = prevEnv;
@@ -920,14 +949,8 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = mapEnv;
           try {
-            this.executeBlock(mapCallback.body);
-            mappedArray.push(null); // If no return, push null
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              mappedArray.push(returnValue.value);
-            } else {
-              throw returnValue;
-            }
+            const result = this.executeFunctionBody(mapCallback);
+            mappedArray.push(result);
           } finally {
             this.environment = prevEnv;
           }
@@ -962,13 +985,7 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = reduceEnv;
           try {
-            this.executeBlock(reduceCallback.body);
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              accumulator = returnValue.value;
-            } else {
-              throw returnValue;
-            }
+            accumulator = this.executeFunctionBody(reduceCallback);
           } finally {
             this.environment = prevEnv;
           }
@@ -1001,13 +1018,7 @@ class Evaluator {
             const prevEnv = this.environment;
             this.environment = sortEnv;
             try {
-              this.executeBlock(sortCallback.body);
-              return 0;
-            } catch (returnValue) {
-              if (returnValue instanceof ReturnException) {
-                return returnValue.value;
-              }
-              throw returnValue;
+              return this.executeFunctionBody(sortCallback) || 0;
             } finally {
               this.environment = prevEnv;
             }
@@ -1040,15 +1051,9 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = findEnv;
           try {
-            this.executeBlock(findCallback.body);
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              if (this.isTruthy(returnValue.value)) {
-                this.environment = prevEnv;
-                return array[i];
-              }
-            } else {
-              throw returnValue;
+            const result = this.executeFunctionBody(findCallback);
+            if (this.isTruthy(result)) {
+              return array[i];
             }
           } finally {
             this.environment = prevEnv;
@@ -1076,15 +1081,9 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = someEnv;
           try {
-            this.executeBlock(someCallback.body);
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              if (this.isTruthy(returnValue.value)) {
-                this.environment = prevEnv;
-                return true;
-              }
-            } else {
-              throw returnValue;
+            const result = this.executeFunctionBody(someCallback);
+            if (this.isTruthy(result)) {
+              return true;
             }
           } finally {
             this.environment = prevEnv;
@@ -1112,15 +1111,9 @@ class Evaluator {
           const prevEnv = this.environment;
           this.environment = everyEnv;
           try {
-            this.executeBlock(everyCallback.body);
-          } catch (returnValue) {
-            if (returnValue instanceof ReturnException) {
-              if (!this.isTruthy(returnValue.value)) {
-                this.environment = prevEnv;
-                return false;
-              }
-            } else {
-              throw returnValue;
+            const result = this.executeFunctionBody(everyCallback);
+            if (!this.isTruthy(result)) {
+              return false;
             }
           } finally {
             this.environment = prevEnv;

package/dist/parser.js

@@ -853,6 +853,11 @@ class Parser {
 
     if (this.match("IDENTIFIER")) {
       const identifier = this.previous();
+      // Check for single-param arrow function: x => ...
+      if (this.check("ARROW")) {
+        this.advance(); // Consume the ARROW
+        return this.arrowFunctionBody([identifier.lexeme]);
+      }
       if (this.check("LEFT_PAREN")) {
         this.advance(); // Consume the LEFT_PAREN
         return this.finishCall(identifier);
@@ -876,6 +881,10 @@ class Parser {
     }
 
     if (this.match("LEFT_PAREN")) {
+      // Check if this could be arrow function params
+      if (this.isArrowFunctionParams()) {
+        return this.arrowFunctionWithParams();
+      }
       const expr = this.expression();
       this.consume("RIGHT_PAREN", "Expected ) after expression");
       return expr;
@@ -1042,6 +1051,109 @@ class Parser {
     };
   }
 
+  /**
+   * Checks if current position looks like arrow function parameters
+   * Looks ahead to find matching ) and checks for =>
+   * @returns {boolean} True if this looks like arrow function params
+   */
+  isArrowFunctionParams() {
+    // Save current position
+    const startPos = this.current;
+
+    // Empty params: () =>
+    if (this.check("RIGHT_PAREN")) {
+      // Check if next is =>
+      if (
+        this.tokens[this.current + 1] &&
+        this.tokens[this.current + 1].type === "ARROW"
+      ) {
+        return true;
+      }
+      return false;
+    }
+
+    // Try to match params pattern: identifier (comma identifier)*
+    let parenDepth = 1;
+    let pos = this.current;
+
+    while (pos < this.tokens.length && parenDepth > 0) {
+      const token = this.tokens[pos];
+      if (token.type === "LEFT_PAREN") {
+        parenDepth++;
+      } else if (token.type === "RIGHT_PAREN") {
+        parenDepth--;
+      }
+      pos++;
+    }
+
+    // pos is now after the matching )
+    // Check if next token is =>
+    if (pos < this.tokens.length && this.tokens[pos].type === "ARROW") {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Parses arrow function with parenthesized parameters
+   * Called after LEFT_PAREN has been consumed
+   * @returns {Object} Arrow function expression
+   */
+  arrowFunctionWithParams() {
+    const parameters = [];
+
+    // Parse parameters
+    if (!this.check("RIGHT_PAREN")) {
+      do {
+        if (parameters.length >= 255) {
+          throw new Error("No se pueden tener más de 255 parámetros");
+        }
+        const param = this.consume(
+          "IDENTIFIER",
+          "Se esperaba un nombre de parámetro",
+        );
+        parameters.push(param.lexeme);
+      } while (this.match("COMMA"));
+    }
+
+    this.consume("RIGHT_PAREN", "Se esperaba ) después de los parámetros");
+    this.consume("ARROW", "Se esperaba => después de los parámetros");
+
+    return this.arrowFunctionBody(parameters);
+  }
+
+  /**
+   * Parses arrow function body (expression or block)
+   * @param {Array} parameters - Function parameters
+   * @returns {Object} Arrow function expression
+   */
+  arrowFunctionBody(parameters) {
+    // Check if body is a block
+    if (this.match("LEFT_BRACE")) {
+      const body = this.block();
+      this.consume(
+        "RIGHT_BRACE",
+        "Se esperaba } después del cuerpo de la función",
+      );
+      return {
+        type: "ArrowFunction",
+        parameters,
+        body,
+        isExpression: false,
+      };
+    }
+
+    // Body is a single expression (implicit return)
+    const expression = this.expression();
+    return {
+      type: "ArrowFunction",
+      parameters,
+      body: expression,
+      isExpression: true,
+    };
+  }
+
   /**
    * Finishes parsing an array access
    * @param {Object} array - The array being accessed

package/dist/tokenizer.js

@@ -67,6 +67,9 @@ class Tokenizer {
         if (this.peek() === "=") {
           this.advance();
           this.addToken("EQUAL_EQUAL");
+        } else if (this.peek() === ">") {
+          this.advance();
+          this.addToken("ARROW");
         } else {
           this.addToken("EQUAL");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hispano-lang",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Un lenguaje de programación educativo en español para enseñar programación sin barreras de idioma",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",