Tabla de Contenidos

• Acerca de HispanoLang
• Inicio Rápido
• Instalación
• Referencia del Lenguaje
  • Variables y Constantes
  • Tipos de Datos
  • Operadores
  • Estructuras de Control
  • Funciones
  • Programación Orientada a Objetos
  • Colecciones
  • Manejo de Errores
• Ejemplos
• API de Node.js
• Arquitectura
• Contribuir
• Licencia

Acerca de HispanoLang

HispanoLang es un lenguaje de programación interpretado con sintaxis completamente en español. Fue diseñado con un objetivo claro: democratizar el acceso a la programación para los más de 500 millones de hispanohablantes en el mundo.

¿Por qué HispanoLang?

La mayoría de los lenguajes de programación utilizan palabras clave en inglés, creando una barrera adicional para quienes están aprendiendo a programar. HispanoLang elimina esta barrera, permitiendo que los estudiantes se concentren en los conceptos fundamentales de la programación sin tener que lidiar simultáneamente con un idioma extranjero.

Características

| Característica | Descripción | | ------------------------------ | ---------------------------------------------------------------------- | | Sintaxis en Español | Palabras clave intuitivas como variable, funcion, si, mientras | | Tipado Dinámico | Sistema de tipos flexible con conversiones automáticas | | POO Completa | Clases, herencia, constructores y métodos | | Funciones de Primera Clase | Funciones como valores, closures y callbacks | | Colecciones Ricas | Arrays y objetos con métodos funcionales integrados | | REPL Interactivo | Experimenta con código en tiempo real | | Integración Node.js | Usa HispanoLang como módulo en proyectos JavaScript | | TypeScript Ready | Definiciones de tipos incluidas |

Inicio Rápido

# Instalar globalmente
npm install -g hispano-lang

# Iniciar el REPL interactivo
hispano

# O ejecutar un archivo
hispano mi_programa.hl

Tu primer programa en HispanoLang:

variable mensaje = "¡Hola, mundo!"
mostrar mensaje

Instalación

Requisitos

• Node.js 20.0.0 o superior
• npm o yarn

Instalación Global (Recomendada)

npm install -g hispano-lang

Instalación como Dependencia

npm install hispano-lang

Desde el Código Fuente

git clone https://github.com/nicvazquezdev/hispano-lang.git
cd hispano-lang
npm install
npm run build
npm link

Verificar Instalación

hispano --version

Referencia del Lenguaje

Variables y Constantes

Variables

Las variables se declaran con la palabra clave variable y pueden ser reasignadas:

variable nombre = "Ana"
variable edad = 25
variable activo = verdadero

edad = 26  // Reasignación permitida

Constantes

Las constantes se declaran con constante y no pueden ser reasignadas:

constante PI = 3.14159
constante MAX_INTENTOS = 3
constante VERSION = "2.0.0"

PI = 3.14  // Error: No se puede reasignar la constante

Tipos de Datos

| Tipo | Ejemplo | Descripción | | ---------- | -------------------- | ------------------------------ | | Número | 42, 3.14, -10 | Enteros y decimales | | Texto | "Hola", 'Mundo' | Cadenas de caracteres | | Booleano | verdadero, falso | Valores lógicos | | Arreglo | [1, 2, 3] | Colección ordenada | | Objeto | { clave: valor } | Colección de pares clave-valor | | Nulo | nulo | Ausencia intencional de valor | | Indefinido | indefinido | Variable sin valor asignado | | Función | funcion() {} | Bloque de código reutilizable | | Clase | clase {} | Plantilla para crear objetos |

Conversión de Tipos

entero("42")        // 42
entero(3.7)         // 3

decimal("3.14")     // 3.14

texto(123)          // "123"
texto(verdadero)    // "verdadero"

booleano(1)         // verdadero
booleano("")        // falso

tipo(42)            // "numero"
tipo("hola")        // "texto"
tipo([1, 2])        // "arreglo"

Operadores

Aritméticos

| Operador | Descripción | Ejemplo | | -------- | -------------- | -------------- | | + | Suma | 5 + 3 → 8 | | - | Resta | 5 - 3 → 2 | | * | Multiplicación | 5 * 3 → 15 | | / | División | 6 / 2 → 3 | | % | Módulo | 7 % 3 → 1 |

Comparación

| Operador | Descripción | Ejemplo | | -------- | ------------- | ---------------------- | | == | Igual a | 5 == 5 → verdadero | | != | Diferente de | 5 != 3 → verdadero | | < | Menor que | 3 < 5 → verdadero | | > | Mayor que | 5 > 3 → verdadero | | <= | Menor o igual | 3 <= 3 → verdadero | | >= | Mayor o igual | 5 >= 5 → verdadero |

Lógicos

| Operador | Descripción | Ejemplo | | -------- | ----------- | --------------------------------- | | y | AND lógico | verdadero y falso → falso | | o | OR lógico | verdadero o falso → verdadero | | ! | NOT lógico | !verdadero → falso |

Asignación Compuesta

variable x = 10
x += 5   // x = 15
x -= 3   // x = 12
x *= 2   // x = 24
x /= 4   // x = 6
x %= 4   // x = 2

Incremento y Decremento

| Operador | Tipo | Descripción | Ejemplo | | -------- | -------- | ----------------------------------- | ----------------------------- | | x++ | Postfijo | Retorna valor original, luego suma | x = 5; mostrar x++ → 5 | | x-- | Postfijo | Retorna valor original, luego resta | x = 5; mostrar x-- → 5 | | ++x | Prefijo | Suma primero, luego retorna | x = 5; mostrar ++x → 6 | | --x | Prefijo | Resta primero, luego retorna | x = 5; mostrar --x → 4 |

variable contador = 5

// Postfijo: retorna el valor ANTES del cambio
mostrar contador++    // Imprime 5, contador ahora es 6
mostrar contador      // Imprime 6

// Prefijo: retorna el valor DESPUÉS del cambio
mostrar ++contador    // Imprime 7, contador ahora es 7
mostrar contador      // Imprime 7

Funcionan también con arrays y objetos:

variable nums = [1, 2, 3]
mostrar ++nums[0]     // Imprime 2, nums[0] ahora es 2

variable obj = { valor: 10 }
mostrar obj.valor++   // Imprime 10, obj.valor ahora es 11

Estructuras de Control

Condicional Si/Sino

si edad >= 18 {
    mostrar "Mayor de edad"
} sino {
    mostrar "Menor de edad"
}

Condicional Si/Sino Si (Else If)

variable nota = 85

si nota >= 90 {
    mostrar "Excelente"
} sino si nota >= 80 {
    mostrar "Muy bien"
} sino si nota >= 70 {
    mostrar "Aprobado"
} sino {
    mostrar "Reprobado"
}

Se pueden anidar condiciones:

variable edad = 25
variable estudiante = verdadero

si edad < 18 {
    mostrar "Menor de edad"
} sino si edad < 30 {
    si estudiante {
        mostrar "Joven estudiante"
    } sino {
        mostrar "Joven trabajador"
    }
} sino {
    mostrar "Adulto"
}

Elegir/Caso (Switch)

elegir opcion {
    caso 1: mostrar "Opción uno"
    caso 2: mostrar "Opción dos"
    caso 3: {
        mostrar "Opción tres"
        mostrar "Con múltiples líneas"
    }
    pordefecto: mostrar "Opción no válida"
}

Bucle Mientras

variable i = 0
mientras i < 5 {
    mostrar i
    i = i + 1
}

Bucle Para

para (variable i = 0; i < 5; i = i + 1) {
    mostrar i
}

Bucle Hacer/Mientras

variable x = 0
hacer {
    mostrar x
    x = x + 1
} mientras x < 3

Bucle Para Cada

variable frutas = ["manzana", "banana", "naranja"]
para cada fruta en frutas {
    mostrar fruta
}

Control de Flujo

mientras verdadero {
    si condicion {
        romper      // Sale del bucle
    }
    si otraCondicion {
        continuar   // Salta a la siguiente iteración
    }
}

Funciones

Declaración y Llamada

funcion saludar(nombre) {
    retornar "Hola, " + nombre
}

mostrar saludar("María")  // "Hola, María"

Funciones Anónimas

variable duplicar = funcion(x) {
    retornar x * 2
}

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

funcion aplicar(valor, operacion) {
    retornar operacion(valor)
}

variable resultado = aplicar(5, funcion(x) { retornar x * x })
mostrar resultado  // 25

Funciones Matemáticas Integradas

raiz(16)           // 4
potencia(2, 8)     // 256
absoluto(-5)       // 5
redondear(3.7)     // 4
piso(3.7)          // 3
techo(3.2)         // 4
seno(0)            // 0
coseno(0)          // 1
tangente(0)        // 0
aleatorio()        // Número entre 0 y 1

Programación Orientada a Objetos

Definición de Clases

clase Persona {
    constructor(nombre, edad) {
        este.nombre = nombre
        este.edad = edad
    }

    saludar() {
        retornar "Hola, soy " + este.nombre
    }

    cumplirAnios() {
        este.edad = este.edad + 1
    }
}

Instanciación

variable persona = nuevo Persona("Carlos", 30)
mostrar persona.nombre      // "Carlos"
mostrar persona.saludar()   // "Hola, soy Carlos"

persona.cumplirAnios()
mostrar persona.edad        // 31

Herencia

clase Empleado extiende Persona {
    constructor(nombre, edad, cargo) {
        super(nombre, edad)
        este.cargo = cargo
    }

    presentarse() {
        retornar este.saludar() + " y trabajo como " + este.cargo
    }
}

variable emp = nuevo Empleado("Ana", 28, "Ingeniera")
mostrar emp.presentarse()  // "Hola, soy Ana y trabajo como Ingeniera"

Verificación de Tipo

variable p = nuevo Persona("Luis", 25)
mostrar tipo(p)  // "Persona"

Colecciones

Arreglos

variable numeros = [1, 2, 3, 4, 5]

// Acceso y modificación
mostrar numeros[0]     // 1
numeros[0] = 10

// Propiedades y métodos básicos
numeros.longitud()     // 5
numeros.primero()      // 10
numeros.ultimo()       // 5
numeros.agregar(6)     // Añade al final
numeros.remover()      // Remueve del final
numeros.contiene(3)    // verdadero

Métodos Funcionales

variable nums = [1, 2, 3, 4, 5]

// Transformación
nums.mapear(funcion(x) { retornar x * 2 })
// [2, 4, 6, 8, 10]

// Filtrado
nums.filtrar(funcion(x) { retornar x > 2 })
// [3, 4, 5]

// Reducción
nums.reducir(funcion(acc, x) { retornar acc + x }, 0)
// 15

// Búsqueda
nums.buscar(funcion(x) { retornar x > 3 })
// 4

// Verificación
nums.algunos(funcion(x) { retornar x > 4 })  // verdadero
nums.todos(funcion(x) { retornar x > 0 })    // verdadero

// Ordenamiento
nums.ordenar()      // [1, 2, 3, 4, 5]
nums.invertir()     // [5, 4, 3, 2, 1]

// Manipulación
nums.cortar(1, 3)         // [2, 3]
nums.insertar(2, 99)      // Inserta 99 en posición 2
nums.unir(", ")           // "1, 2, 3, 4, 5"

Iteración

variable colores = ["rojo", "verde", "azul"]
colores.recorrer(funcion() {
    mostrar "Color: " + elemento + " en índice " + indice
})

Objetos

variable persona = {
    nombre: "Elena",
    edad: 32,
    ciudad: "Madrid"
}

mostrar persona.nombre     // "Elena"
persona.edad = 33          // Modificar
persona.profesion = "Dev"  // Añadir propiedad

Cadenas de Texto

variable texto = "Hola Mundo"

// Propiedades
texto.longitud()          // 10

// Transformación
texto.mayusculas()        // "HOLA MUNDO"
texto.minusculas()        // "hola mundo"
texto.recortar()          // Elimina espacios extremos
texto.invertir()          // "odnuM aloH"

// Búsqueda
texto.incluye("Mundo")    // verdadero
texto.empiezaCon("Hola")  // verdadero
texto.terminaCon("Mundo") // verdadero

// Extracción
texto.caracter(0)         // "H"
texto.subcadena(0, 4)     // "Hola"

// Manipulación
texto.dividir(" ")        // ["Hola", "Mundo"]
texto.reemplazar("Mundo", "Amigo")  // "Hola Amigo"

Interpolación de Cadenas

variable nombre = "María"
variable edad = 25

mostrar `Hola ${nombre}, tienes ${edad} años`
// "Hola María, tienes 25 años"

mostrar `El doble de tu edad es ${edad * 2}`
// "El doble de tu edad es 50"

Métodos Numéricos

variable n = 42

n.esPar()        // verdadero
n.esImpar()      // falso
n.esPositivo()   // verdadero
n.esNegativo()   // falso
n.aTexto()       // "42"

Manejo de Errores

intentar {
    variable resultado = operacionRiesgosa()
    mostrar resultado
} capturar (error) {
    mostrar "Ocurrió un error: " + error
}

Ejemplos

Calculadora Simple

funcion calculadora(a, b, operacion) {
    elegir operacion {
        caso "+": retornar a + b
        caso "-": retornar a - b
        caso "*": retornar a * b
        caso "/": {
            si b == 0 {
                retornar "Error: División por cero"
            }
            retornar a / b
        }
        pordefecto: retornar "Operación no válida"
    }
}

mostrar calculadora(10, 5, "+")  // 15
mostrar calculadora(10, 5, "*")  // 50

Fibonacci

funcion fibonacci(n) {
    si n <= 1 {
        retornar n
    }
    retornar fibonacci(n - 1) + fibonacci(n - 2)
}

para (variable i = 0; i < 10; i = i + 1) {
    mostrar fibonacci(i)
}

Sistema de Gestión

clase Producto {
    constructor(nombre, precio) {
        este.nombre = nombre
        este.precio = precio
    }
}

clase Carrito {
    constructor() {
        este.productos = []
    }

    agregar(producto) {
        este.productos.agregar(producto)
    }

    total() {
        retornar este.productos.reducir(
            funcion(acc, p) { retornar acc + p.precio },
            0
        )
    }

    mostrarResumen() {
        mostrar "=== Carrito de Compras ==="
        para cada producto en este.productos {
            mostrar `${producto.nombre}: $${producto.precio}`
        }
        mostrar `Total: $${este.total()}`
    }
}

variable carrito = nuevo Carrito()
carrito.agregar(nuevo Producto("Laptop", 999))
carrito.agregar(nuevo Producto("Mouse", 29))
carrito.agregar(nuevo Producto("Teclado", 79))
carrito.mostrarResumen()

API de Node.js

Uso como Módulo

const { interpret, run } = require("hispano-lang");

// Interpretar código y obtener resultado completo
const result = interpret(`
    variable x = 10
    mostrar x * 2
`);

console.log(result.success); // true
console.log(result.output); // ['20']
console.log(result.error); // null

// Ejecutar y obtener solo la salida
const output = run(`mostrar "Hola desde Node.js"`);
console.log(output); // ['Hola desde Node.js']

TypeScript

import { interpret, InterpretationResult } from "hispano-lang";

const result: InterpretationResult = interpret(`
    variable mensaje = "TypeScript + HispanoLang"
    mostrar mensaje
`);

Arquitectura

HispanoLang utiliza una arquitectura de intérprete clásica con tres fases:

┌─────────────┐     ┌────────────┐     ┌─────────────┐
│  Tokenizer  │ ──▶ │   Parser   │ ──▶ │  Evaluator  │
│  (Léxico)   │     │ (Sintaxis) │     │ (Ejecución) │
└─────────────┘     └────────────┘     └─────────────┘
      │                   │                   │
      ▼                   ▼                   ▼
   Tokens              AST               Resultado

Estructura del Proyecto

hispano-lang/
├── src/
│   ├── tokenizer.js    # Análisis léxico
│   ├── parser.js       # Análisis sintáctico → AST
│   ├── evaluator.js    # Evaluación del AST
│   └── interpreter.js  # Orquestador principal
├── bin/
│   └── hispano.js      # CLI
├── test/
│   └── test.js         # Suite de tests (334+)
└── dist/               # Build de producción

Contribuir

Las contribuciones son bienvenidas. Por favor, lee las siguientes guías antes de contribuir.

Configuración del Entorno

git clone https://github.com/nicvazquezdev/hispano-lang.git
cd hispano-lang
npm install
npm test

Flujo de Trabajo

1. Fork del repositorio
2. Crear rama feature: git checkout -b feature/nueva-funcionalidad
3. Commit de cambios: git commit -m 'Añadir nueva funcionalidad'
4. Push a la rama: git push origin feature/nueva-funcionalidad
5. Crear Pull Request

Estándares de Código

• Ejecutar npm run lint antes de commit
• Ejecutar npm run format para formatear código
• Añadir tests para nuevas funcionalidades
• Mantener cobertura de tests existente

Reportar Bugs

Abre un issue incluyendo:

• Descripción del problema
• Código para reproducir
• Comportamiento esperado vs actual
• Versión de Node.js y sistema operativo

Licencia

Distribuido bajo la Licencia MIT. Ver LICENSE para más información.

Autor

Nicolas Vazquez

• GitHub: @nicvazquezdev
• Email: [email protected]