Cambios Semánticos y de Léxico

Forja ha evolucionado significativamente desde sus inicios. Este documento cataloga todos los cambios semánticos y de léxico —traducciones de palabras clave, renombres de constructores, cambios de sintaxis y evolución del sistema de tipos— que han ocurrido durante el desarrollo del lenguaje.

1. Léxico: Palabras Clave Traducidas al Español

Forja es un lenguaje en español. Todas las palabras clave del lenguaje están en español (con algunas excepciones por compatibilidad). El mapeo completo se encuentra en src/lexer.rs:132-191.

1.1. Palabras Clave Principales

Forja (Español)	Equivalente en otros lenguajes	Compatibilidad (inglés)	Descripción
`variable` / `var`	`let`, `var`	—	Declara una variable mutable
`constante` / `const`	`const`	`const`	Declara una constante inmutable
`funcion` / `fun`	`function`, `fn`	`fun`	Declara una función o método
`si`	`if`	—	Inicia un bloque condicional
`sino`	`else`	—	Rama alternativa de un condicional
`mientras`	`while`	—	Bucle controlado por condición
`para`	`for`	—	Bucle clásico de estilo C
`repetir`	`loop`, `repeat`	—	Bucle de repetición fija
`romper` / `break`	`break`	`break` ✅	Sale del bucle activo
`continuar` / `continue`	`continue`	`continue` ✅	Pasa a la siguiente iteración
`retornar`	`return`	—	Devuelve un valor desde una función
`importar`	`import`	—	Carga módulos externos
`clase`	`class`	—	Declara una clase
`tipo`	`type`, `enum`	—	Declara un tipo algebraico (enum)
`coincidir`	`match`	—	Pattern matching
`caso`	`case`	—	Brazo de pattern matching
`rasgo`	`trait`, `interface`	—	Define interfaces / traits
`implementa`	`impl`, `implements`	—	Implementa un rasgo para una clase
`donde`	`where`	—	Cláusula de restricciones de tipo
`nuevo`	`new`	—	Instancia una clase
`este`	`this`, `self`	—	Referencia a la instancia actual
`constructor`	`constructor`, `init`	—	Declara el constructor de una clase
`prestado`	`ref`, `&`	—	Referencia prestada (borrowing)
`mut`	`mut`	`mut` ✅	Modificador de mutabilidad
`verdadero`	`true`	—	Literal booleano verdadero
`falso`	`false`	—	Literal booleano falso
`nulo`	`null`	—	Valor nulo / ausencia de valor

1.2. Concurrencia y Canales

Forja (Español)	Equivalente	Descripción
`hilo`	`thread`	Lanza un hilo de ejecución
`canal`	`channel`	Crea un canal de comunicación
`enviar`	`send`	Envía un mensaje por un canal
`recibir`	`recv`, `receive`	Recibe un mensaje de un canal
`unir`	`join`	Espera la finalización de un hilo
`seleccionar`	`select`	Selección no bloqueante de canales
`tiempo`	`timeout`	Rama de timeout en seleccionar
`otro`	`default`	Rama por defecto en seleccionar

1.3. Design by Contract

Forja (Español)	Equivalente (Eiffel)	Descripción
`requiere`	`require`	Precondición de función
`asegura`	`ensure`	Postcondición de función
`siempre`	`invariant`	Invariante de clase
`resultado`	`Result`	Valor de retorno en postcondiciones
`anterior`	`old`	Valor anterior en postcondiciones

1.4. Funciones Built-in y Misceláneas

Forja	Equivalente	Descripción
`escribir`	`print`, `println`	Imprime en la terminal
`leer`	`read`, `input`	Lee entrada del usuario
`BD`	`db`	Palabra clave para operaciones de base de datos
`externo` / `externa`	`extern`	Firma de función externa (FFI)
`cuando`	`when`, `onchange`	Bloque reactivo / observer

1.5. Operadores Lógicos (cambio histórico)

Forja actual	Anteriormente	Equivalente
`y`	`and` / `&&`	`&&`
`o`	`or` / `\|\|`	`\|\|`
`no`	`not` / `!`	`!`

⚠️ Nota: Los operadores &&, || y ! también son válidos. La versión textual en español es la recomendada.

2. Constructores de Option y Resultado

Forja soporta tipos algebraicos Opcion (Option) y Resultado (Result) directamente como variantes del AST (expresiones nativas), sin necesidad de un prelude. Los constructores aceptan tanto su forma en español como su forma en inglés para compatibilidad máxima.

Archivo fuente: src/ast.rs, src/bytecode.rs:1689-1694

Tipo	Constructor	Variantes aceptadas	Tag interno
`Opcion`	`Alguno(valor)`	`Alguno`, `Algo`, `Some`	`"some"`
`Opcion`	`Ninguno()`	`Ninguno`, `None`	`"none"`
`Resultado`	`Ok(valor)`	`Ok`	`"ok"`
`Resultado`	`Error(valor)`	`Error`, `Err`	`"error"`

2.1. Uso en código

Ejemplo: Option y Resultado en Forja

// Las tres formas son equivalentes:
variable a = Alguno(42)
variable b = Algo(42)
variable c = Some(42)

// Pattern matching con constructores en español:
coincidir (a) {
    caso Alguno(v) => escribir("Tengo: ", v)
    caso Ninguno => escribir("No hay valor")
}

// Resultado:
variable res = Ok("exitoso")
variable err = Error("falló")

// También funciona con inglés:
variable res2 = Ok("ok")
variable err2 = Err("error")

2.2. Pattern matching interno

Cuando se usa coincidir con estos constructores, el compilador genera bytecode que inspecciona el campo "tipo" del objeto (vía GetField("tipo")) y lo compara con el tag interno. Si hay subpatrones (ej: Alguno(v)), extrae el campo "valor" y lo asigna a la variable.

Bytecode generado para caso Alguno(v)

Dup
GetField("tipo")
PushTexto("some")
Igual
JumpSiFalso(label_next)
GetField("valor")
Store("v")
[ejecutar cuerpo]
Label(label_next)

ℹ️ Para más detalles sobre este proceso, ver src/bytecode.rs:1687-1784 y src/parser.rs:2139-2161.

3. Tipos de Datos Primitivos

Los nombres de tipos en Forja están en español y se manejan como soft keywords (identificadores que el parser reconoce como tipos en contexto). Ver src/lexer.rs:182-190.

Forja	Rust	Descripción
`Entero`	`i64`	Entero con signo de 64 bits
`Decimal`	`f64`	Número de punto flotante de 64 bits
`Texto`	`String`	Cadena de caracteres
`Booleano`	`bool`	Valor booleano (verdadero/falso)
`Exacto`	`(i128, u32)`	Número decimal de precisión arbitraria (BigDecimal)
`Nulo`	`()`	Unidad / ausencia de valor

4. Evolución del Sistema de Tipos (AST)

El AST de Forja (src/ast.rs) ha evolucionado para incluir variantes específicas para los tipos algebraicos. Ver la tabla completa de Tipo y Expresion en la página del AST.

4.1. Tipo enum

Evolución del enum Tipo:

Variante	Significado	Cambio semántico
`Entero`	Entero i64	Originalmente era `Int` → renombrado a `Entero`
`Decimal`	Flotante f64	Originalmente `Float` → renombrado
`Texto`	String	Originalmente `String` → renombrado
`Booleano`	Bool	Originalmente `Bool` → renombrado
`Nulo`	Unidad	Agregado posteriormente
`Exacto`	BigDecimal	Agregado para el sistema `Exacto` con precisión arbitraria
`Clase(String, Vec<Tipo>)`	Clase/objeto	Evolucionó de un simple nombre a incluir parámetros genéricos
`Arreglo(Box<Tipo>)`	Array	Agregado para listas tipadas
`Funcion(Vec<Tipo>, Box<Tipo>)`	Firma de función	Agregado para tipos función (params → retorno)
`Resultado(Box<Tipo>, Box<Tipo>)`	Result (ok, error)	Agregado para el tipo Resultado
`Opcion(Box<Tipo>)`	Option	Agregado para el tipo Opcion
`RasgoObjeto(String)`	Trait object	Agregado para polimorfismo dinámico
`Parametro(String)`	Parámetro genérico	Agregado para genéricos

4.2. Expresiones de Option y Resultado

El enum Expresion incluye variantes específicas para tipos algebraicos:

Variante	Antes	Ahora	Descripción
`Algo(Box<Expresion>)`	`Some(expr)`	`Algo(expr)`	Constructor de Opcion con valor
`Ninguno`	`None`	`Ninguno`	Constructor de Opcion vacío
`Ok(Box<Expresion>)`	`Ok(expr)`	`Ok(expr)`	Constructor de Resultado exitoso
`Error(Box<Expresion>)`	`Err(expr)`	`Error(expr)`	Constructor de Resultado fallido

5. Nombres de Opcodes y Micro-Operaciones

Los opcodes del bytecode (src/bytecode.rs) y las micro-operaciones (src/uops.rs) usan nombres en español o spanglish técnico:

Uop / Opcode	Traducción	Descripción
`PushEntero`	Push Integer	Apila un entero
`PushDecimal`	Push Decimal	Apila un float
`PushTexto`	Push Text	Apila una cadena
`PushBooleano`	Push Boolean	Apila un booleano
`PushNulo`	Push Null	Apila el valor nulo
`JumpSiFalso`	Jump If False	Salto condicional si es falso
`DeclareVar`	Declare Variable	Declara una variable en el ámbito actual
`IncrVar`	Increment Variable	Optimización: incremento directo
`ResolveMethod`	Resolve Method	Resolución de método virtual
`LoadSelf`	Load Self	Carga `este` en el stack
`CallNative`	Call Native	Llama a función nativa registrada

6. Cambios en la CLI

Los comandos de la interfaz de línea de comandos aceptan tanto español como inglés:

Comando en español	Comando en inglés	Función
`forja correr`	`forja run`	Ejecutar un archivo
`forja ejecutar`	`forja run`	Ejecutar un archivo
`forja compilar`	`forja build`	Generar ejecutable
`forja construir`	`forja build`	Generar ejecutable
`forja formatear`	`forja fmt`	Formatear código
`forja medir`	`forja bench`	Medir rendimiento
`forja diagrama`	`forja diagram`	Generar diagrama del AST
`forja grafico`	`forja graph`	Generar diagrama del AST
`forja nuevo`	`forja new`	Crear nuevo proyecto
`forja crear`	`forja new`	Crear nuevo proyecto
`forja ayuda`	`forja help`	Mostrar ayuda
`forja colorear`	`forja highlight`	Colorear sintaxis
`forja explicar`	`forja explain`	Explicar un concepto
`forja aprender`	`forja learn`	Tutorial interactivo
`forja transpilar`	`forja transpile`	Transpilar a Rust
`forja interactivo`	`forja repl`	Modo interactivo REPL

7. Convenciones de Nomenclatura en Código Rust

El código fuente del compilador de Forja (Rust) usa una mezcla de nomenclatura en español e inglés. Las estructuras, funciones y tipos públicos tienden a usar spanglish técnico:

7.1. Estructuras y Tipos en Rust

Nombre Rust	Traducción / Notas
`TokenKind`	Mantiene el inglés, pero los valores del enum están en español: `Si`, `Sino`, `Funcion`, etc.
`ValorFast`	Spanglish: "Fast" por ForjaFast, "Valor" en español
`ForjaFast`	Nombre en español + "Fast" técnico
`FrmFast`	Contracción de "Frame Fast"
`CompiledCode`	Inglés, pero funciones asociadas pueden usar español
`CodeBuf`	Código + Buffer (inglés)
`ClassDescriptor`	Inglés técnico
`TablaSimbolos`	Español completo
`BorrowChecker`	Inglés (término técnico estándar)
`TypeChecker`	Inglés (término técnico estándar)
`LlvmBackend`	Spanglish
`CompilerAsm`	Spanglish
`TargetArch`	Inglés técnico
`JitOrchestrator`	Spanglish (Orquestador JIT)
`StackCache`	Inglés técnico (aunque `stack` se usa como préstamo)

7.2. Funciones en Rust con nombres en español

Función	Traducción
`generar_prelude()`	Generate prelude
`expandir_a_uops()`	Expand to uops
`remapear_saltos_uops()`	Remap jump uops
`construir_mapeo_posiciones()`	Build position map
`fusionar_opcodes()`	Fuse opcodes
`sanitizar_para_serializacion()`	Sanitize for serialization
`obtener_tag_constructor()`	Get constructor tag
`emitir_subpatrones_constructor()`	Emit constructor subpatterns
`inferir_tipo_expresion()`	Infer expression type
`resolver_nombre_mangled()`	Resolve mangled name
`encontrar_variables_en_expr()`	Find variables in expression
`tiene_anterior()`	Has predecessor
`recolectar_clases()`	Collect classes
`compilar_expresion_asm()`	Compile ASM expression
`compilar_declaracion()`	Compile declaration

7.3. Funciones con nombre mixto o en inglés

Función	Notas
`peek()`, `advance()`, `match()`	Métodos de parser/lexer — nombres técnicos universales
`tokenize()`, `parse()`, `compile()`	Nombres técnicos estándar de compiladores
`intern()`, `intern_rc()`, `get()`	Symbol table — API en inglés
`ejecutar()`, `ejecutar_uops()`	VM — español. Originalmente `execute()`
`cargar_bytecode()`	Spanglish: "cargar" (español) + "bytecode" (inglés)
`push_valor()`, `pop_valor()`	Spanglish: "push/pop" (técnico) + "valor" (español)
`alloc_obj()`, `alloc_str()`	Spanglish: "alloc" (inglés) + "obj/str" (abreviaturas)

8. Historial de Cambios Semánticos Relevantes

8.1. Eliminación de `mut` en variables locales

Inicialmente Forja requería mut en toda variable mutable (como Rust). Se simplificó: ahora variable implica mutabilidad por defecto, y constante implica inmutabilidad. mut se conserva solo para parámetros de función y referencias prestadas.

8.2. De `String` a `Texto`

El tipo de cadena de caracteres se renombró de String a Texto para mantener coherencia con el idioma español. El cambio fue únicamente de nombre; la representación interna sigue siendo un String de Rust.

8.3. De `Bool` a `Booleano`

El tipo booleano se renombró de Bool a Booleano siguiendo la misma filosofía de españolización.

8.4. De `None`/`Some` a `Ninguno`/`Alguno`

Los constructores de Option se renombraron manteniendo compatibilidad hacia atrás. Actualmente se aceptan: Alguno, Algo, Some para el caso con valor; y Ninguno, None para el caso vacío. Ver sección 2 arriba.

8.5. De `interface`/`trait` a `rasgo`

Originalmente Forja usaba trait (como Rust) e interface (como Java). Se unificó bajo rasgo para mantener el español.

8.6. Adición de Design by Contract

Forja incorporó posteriormente requiere, asegura, siempre, resultado y anterior como keywords para el sistema de contratos (inspirado en Eiffel). Estas palabras no existían en versiones iniciales del lenguaje.

8.7. De `println`/`print` a `escribir`

Las funciones de salida estándar se renombraron de println/print a escribir. Sigue aceptando múltiples argumentos separados por coma.

8.8. Adición del tipo `Exacto`

Se agregó posteriormente el tipo Exacto para aritmética de precisión arbitraria (basado en (i128, u32) para coeficiente y escala), incluyendo soporte completo en el bytecode (Opcode::SumaExact, Opcode::MulExact, etc.) y en la VM ForjaFast.

8.9. De `self`/`this` a `este`

La palabra clave para referirse a la instancia actual evolucionó de aceptar self (como Rust/Python) y this (como Java/JS) a la forma unificada este en español.

9. Compatibilidad con Inglés

Forja mantiene compatibilidad selectiva con inglés para facilitar la migración desde otros lenguajes. Las siguientes palabras clave aceptan su forma inglesa:

Español (recomendado)	Inglés (compatible)	Contexto
`romper`	`break`	Bucles
`continuar`	`continue`	Bucles
`funcion`	`fun`	Declaración de funciones
`variable`	`var`	Declaración de variables
`constante`	`const`	Declaración de constantes
`externo`	`externa`	FFI
`Alguno`	`Some`, `Algo`	Constructor Option
`Ninguno`	`None`	Constructor Option
`Error`	`Err`	Constructor Resultado
`y`	`&&`	Operador lógico
`o`	`\|\|`	Operador lógico
`no`	`!`	Operador lógico

10. Referencias en el Código Fuente

Todas las referencias a los archivos fuente relevantes:

Lexer (keywords): src/lexer.rs:132-191 — mapeo completo de palabras clave
Parser (constructores): src/parser.rs:2139-2161 — detección de Ok/Error/Algo/Some/None
Bytecode (tags): src/bytecode.rs:1689-1694 — mapeo de constructores a tags internos
AST (tipos): src/ast.rs:38-60 — enum Tipo con todas las variantes
AST (expresiones): src/ast.rs:157-275 — enum Expresion con Algo/Ninguno/Ok/Error
Token (enums): src/token.rs — TokenKind con todas las keywords
Transpiler (mapeo): src/transpiler.rs:2782-2784 — Error → Err para Rust
LSP (snippets): src/lsp/snippets.rs — snippets con palabras clave en español