Tipos de datos

Forja es tipado estáticamente con inferencia de tipos. No necesitás declarar el tipo siempre, pero podés hacerlo si querés mayor claridad.

Tabla de tipos

Tipo Forja	Tipo Rust	Descripción	Ejemplo
`Entero`	`i64`	Entero con signo (64 bits)	`42`, `-10`
`Decimal`	`f64`	Punto flotante (64 bits)	`3.14`, `-0.5`
`Texto`	`String`	Cadena UTF-8	`"Hola"`
`Booleano`	`bool`	Valor lógico	`verdadero`, `falso`
`Exacto`	`BigDecimal`	Precisión arbitraria (coeficiente i128 + escala)	`3.1415926535`
`nulo`	`()`	Valor nulo / unit	`nulo`
`[T]`	`Vec<T>`	Arreglo dinámico	`[1, 2, 3]`
`{K: V}`	`HashMap<K, V>`	Mapa / diccionario	`{"clave": "valor"}`
`Tipo`	`enum`	Algebraico (con `tipo`)	`Opcion = Algo \| Nada`

Booleanos en español

En lugar de true / false, Forja usa palabras en español:

🔘 Valores booleanos

variable activo = verdadero
variable inactivo = falso
variable es_mayor = edad >= 18  // resultado: verdadero o falso

Literales numéricos

🔢 Números

variable entero = 42       // Entero (i64)
variable decimal = 3.14    // Decimal (f64)
variable negativo = -10    // Entero negativo

Literales de texto

📝 Strings

variable saludo = "Hola mundo"

// Caracteres de escape
variable multilinea = "Línea 1\nLínea 2"
variable tabulado = "Col1\tCol2"

Interpolación de cadenas

Podés incrustar expresiones dentro de literales de texto usando {expresion} o ${expresion}:

🔗 Interpolación

variable nombre = "Mundo"
variable edad = 25

// Interpolación directa con llaves
escribir("Hola {nombre}, tenés {edad} años")

// Interpolación con dólar-llave (expresiones complejas)
escribir("Resultado: ${2 + 3}")

// Escape: \{ produce una llave literal
escribir("Llave literal: \{no interpola\}")

💡 Ambas formas ({expr} y ${expr}) son equivalentes. Usá la que te resulte más cómoda. Para incluir llaves literales, escapá con \{ y \}.

Arreglos

📦 Colecciones

variable numeros = [1, 2, 3, 4, 5]
variable nombres = ["Ana", "Juan", "Pedro"]

// Acceso por índice
numeros[0]  // → 1

// Longitud
numeros.longitud()  // → 5 (alias: .length())

// Modificar
numeros[2] = 99

// Agregar al final
numeros.empujar(6)  // (alias: .push())

Mapas (diccionarios)

🗺️ Mapas

variable persona = {"nombre": "Ana", "edad": 30}
// Acceso por clave
persona["nombre"]  // → "Ana"

// Acceso con sintaxis de punto (equivalente)
persona.nombre  // → "Ana"
persona.edad    // → 30

// Modificar valor
persona["edad"] = 31

💡 La sintaxis mapa.clave es azúcar sintáctico para mapa["clave"]. Podés usar ambas formas indistintamente.

Métodos integrados en primitivos

Los tipos Texto y Arreglo tienen métodos integrados que podés llamar con sintaxis orientada a objetos:

Métodos de `Texto`

Método	Alias	Descripción	Ejemplo
`.longitud()`	`.length()`	Cantidad de caracteres	`"hola".longitud()` → `4`
`.a_mayusculas()`	`.to_upper()`	Convierte a mayúsculas	`"hola".a_mayusculas()` → `"HOLA"`
`.a_minusculas()`	`.to_lower()`	Convierte a minúsculas	`"HOLA".a_minusculas()` → `"hola"`
`.contiene(sub)`	`.contains(sub)`	Verifica si contiene subcadena	`"hola".contiene("ol")` → `verdadero`
`.dividir(sep)`	`.split(sep)`	Divide por separador	`"a,b,c".dividir(",")` → `["a", "b", "c"]`
`.recortar()`	`.trim()`	Elimina espacios	`" hola ".recortar()` → `"hola"`
`.invertir()`	`.reverse()`	Invierte la cadena	`"abc".invertir()` → `"cba"`
`.reemplazar(a, b)`	`.replace(a, b)`	Reemplaza ocurrencias	`"hola".reemplazar("o", "0")` → `"h0la"`

Métodos de `Arreglo`

Método	Alias	Descripción	Ejemplo
`.longitud()`	`.length()`	Cantidad de elementos	`[1,2,3].longitud()` → `3`
`.empujar(elem)`	`.push(elem)`	Agrega al final	`arr.empujar(4)`
`.obtener(i)`	`.get(i)`	Obtiene por índice	`arr.obtener(0)`
`.remover(i)`	`.remove(i)`	Elimina por índice	`arr.remover(1)`

Tipos algebraicos (enums)

Forja permite definir tipos algebraicos con la palabra clave tipo. Son ideales para representar datos que pueden tomar diferentes formas.

📐 Sintaxis

tipo Nombre = Variante1 | Variante2 | Variante3(Tipo1, Tipo2)

🎯 Ejemplos

// Opción: puede ser Algo (con valor) o Nada
tipo Opcion = Algo | Nada

// Resultado: Exito con valor, o Error con mensaje
tipo Resultado = Exito(Entero) | Error(Texto)

// Color: variantes sin datos extra
tipo Color = Rojo | Verde | Azul

Tipos compuestos

Forja también ofrece tipos compuestos para colecciones y resultados:

Tipo Forja	Descripción	Ejemplo
`Arreglo[T]`	Arreglo dinámico de elementos `T`	`[1, 2, 3]`
`Mapa{K: V}`	Mapa / diccionario con claves `K` y valores `V`	`{"clave": "valor"}`
`Resultado<T, E>`	Operación que puede ser `Exito(T)` o `Error(E)`	`Resultado<Entero, Texto>`
`Opcion<T>`	Valor opcional: `Algun(T)` o `Ninguno`	`Opcion<Texto>`

Anotaciones explícitas

Cuando querés ser específico con los tipos:

📝 Tipado explícito

variable nombre: Texto = "Ana"
variable edad: Entero = 25
variable altura: Decimal = 1.75
constante activo: Booleano = verdadero

Equivalencia con Rust

Forja	Rust
`Entero`	`i64`
`Decimal`	`f64`
`Texto`	`String`
`Booleano`	`bool`
`nulo`	`()`
`Exacto`	`BigDecimal`
`[valor, ...]`	`vec![valor, ...]`
`{"k": v}`	`HashMap`
`tipo X = A \| B`	`enum X { A, B }`