Operadores

Forja soporta los operadores clásicos de la programación, organizados por categorías. Incluye operadores aritméticos, relacionales, lógicos, de referencia, asignación compuesta y acceso.

Aritméticos

Op	Descripción	Ejemplo	Resultado
`+`	Suma / concatenación	`5 + 3` / `"a" + "b"`	`8` / `"ab"`
`-`	Resta	`10 - 4`	`6`
`*`	Multiplicación	`6 * 7`	`42`
`/`	División	`20 / 5`	`4`
`%`	Módulo (resto)	`10 % 3`	`1`

💡 El operador + también concatena strings: "Hola " + "mundo" → "Hola mundo"

Asignación compuesta

Op	Descripción	Ejemplo	Equivale a
`+=`	Suma acumulada	`x += 1`	`x = x + 1`
`-=`	Resta acumulada	`x -= 1`	`x = x - 1`
`*=`	Multiplicación acumulada	`x *= 2`	`x = x * 2`
`/=`	División acumulada	`x /= 2`	`x = x / 2`
`%=`	Módulo acumulado	`x %= 2`	`x = x % 2`

Relacionales

Op	Descripción	Ejemplo
`>`	Mayor que	`x > 5`
`<`	Menor que	`x < 10`
`>=`	Mayor o igual	`x >= 18`
`<=`	Menor o igual	`x <= 100`
`==`	Igualdad	`x == 5`
`!=`	Diferente	`x != 0`

Lógicos

Op	Descripción	Ejemplo
`&&`	Y (AND)	`activo && edad >= 18`
`\|\|`	O (OR)	`x == 0 \|\| y == 0`
`!` / `no`	NO (NOT)	`!activo` / `no activo`

💡 Además de !, podés usar la keyword no como operador de negación lógica en español: si (no activo) { ... }

Referencia y acceso

Op	Descripción	Ejemplo
`&`	Referencia (préstamo inmutable)	`&variable`
`.`	Acceso a miembro/método	`objeto.campo`, `obj.metodo()`
`[]`	Acceso por índice (arreglos y mapas)	`arr[0]`, `mapa["clave"]`
`->`	Flecha de retorno o brazo de match	`-> Entero`, `caso 1 -> "uno"`
`::`	Acceso cualificado a módulo/trait	`std::io`, `Volador::volar`
`..`	Rango	`1..10`
`?`	Propagación de errores (try)	`valor?`

⚡ Propagación de errores: El operador ? propaga errores automáticamente. Si la expresión es Error(msg), la función retorna el error. Si es Exito(valor), extrae el valor. Ideal para encadenar operaciones fallibles.

Operador ternario

El operador ternario permite expresiones condicionales en línea:

❓ Ternario

variable edad = 20
variable categoria = edad >= 18 ? "Mayor" : "Menor"
escribir(categoria) // → "Mayor"

// Se puede anidar (aunque se recomienda usar si/sino para legibilidad)
variable precio = edad > 65 ? 0 : (edad >= 18 ? 100 : 50)

Op	Sintaxis	Descripción
`? :`	`cond ? val_si : val_no`	Si `cond` es verdadero retorna `val_si`, sino `val_no`

Precedencia de operadores

De mayor a menor precedencia. Los operadores con mayor precedencia se evalúan primero:

Nivel	Operadores	Descripción
1 (más alta)	`!`, `-` (unarios), `&`	Negación, negación aritmética, referencia
2	`*`, `/`, `%`	Multiplicación, división, módulo
3	`+`, `-`	Suma, resta
4	`>`, `<`, `>=`, `<=`	Comparaciones relacionales
5	`==`, `!=`	Igualdad y diferencia
6	`&&`	Y lógico
7 (más baja)	`\|\|`	O lógico

Usá paréntesis ( ... ) para agrupar y forzar precedencia:

📐 Agrupación

variable resultado = (2 + 3) * (10 - 5)
// resultado = 25

// Sin paréntesis sería 2 + 3 * 10 - 5 = 27