# SiPi runtime en Rust (prototipo)

Tokenizador + parser + evaluador de **expresiones** de SiPi escrito en
Rust, replica deliberada de `src/lexer_sipi.py` / `src/ast_sipi.py`:
misma gramatica, misma precedencia de operadores, mismos alias en
espanol (`y`/`o`/`no`), misma semantica de evaluacion (concatenacion
texto+numero, division/modulo por cero como error, cortocircuito real
en `and`/`or`).

## Alcance (leer antes de esperar mas de lo que hay)

Esto evalua **expresiones sueltas** — `2 + 3 * 4`, `"Puntaje: " + x`,
`edad >= 18 and tiene_permiso` — nada mas. **No** ejecuta programas
`.sipi` completos: no hay control de flujo (`si`/`mientras`/`repetir`),
no hay funciones definidas por el usuario ni llamadas, no hay clases,
listas, ni el resto de los ~290 comandos del motor real. Es
deliberadamente la pieza mas chica y mas facil de verificar antes de
plantearse escalar a algo mas grande — misma filosofia que la fase 1
del lexer/parser/AST en Python (`lexer_sipi.py`/`ast_sipi.py`), que
tampoco reemplaza a `sipi.py`.

## Por que existe

No para reemplazar al interprete de Python en producción (`sipi.py`
sigue siendo el motor real y el unico que ejecuta programas completos)
sino como validacion cruzada: si tres implementaciones independientes
del mismo pedazo de gramatica (Rust, `ast_sipi.py`, y
`Interprete.evaluar_expresion` del motor real) coinciden exactamente
en el mismo lote de expresiones, es una señal fuerte de que la
gramatica esta bien especificada y no hay ambiguedad escondida. Ver
`src/tests/test_paridad_rust.py` para esa validacion cruzada real
(compila el binario y compara los tres resultados, expresion por
expresion).

## Compilar y probar

```bash
cd runtime_rust
cargo build --release
cargo test          # tests unitarios de Rust (lexer + parser/evaluador)
```

## Uso del binario

```bash
./target/release/sipi_runtime_rust '2 + 3 * 4'
# {"ok":true,"tipo":"numero","valor":14}

./target/release/sipi_runtime_rust 'x + z' 'x=2' 'z=3'
# {"ok":true,"tipo":"numero","valor":5}

./target/release/sipi_runtime_rust '1 / 0'
# {"ok":false,"error":"Division por cero al evaluar la expresion '1 / 0'."}
```

Imprime un JSON de una sola linea escrito a mano (sin dependencias
externas, misma filosofia que `sipi.py`/`sipi_lsp.py` del lado
Python) para que sea facil de parsear desde cualquier script, incluido
el test de paridad de tres vias.

## Que sigue (no incluido a proposito en esta pasada)

Escalar esto a ejecutar programas `.sipi` completos (control de flujo,
funciones, el resto de los comandos) es un proyecto en si mismo, no
una extension chica de este prototipo — queda deliberadamente afuera
hasta que se decida si vale la pena esa inversion.
