---
slug: 10-syntax
title: Sintaxis
description: Sintaxis de Synsema — variables con let/set, operadores, el pipe unario, condicionales inline, strings y bloques por indentación.
example_ids: [syntax]
---

# Sintaxis

Synsema se lee como prosa. Los bloques se definen por **indentación** (4 espacios o 1 tab) — no hay llaves.

> ¿Venís de Python? Leé primero [Python → Synsema — la tabla de traducción](/es/0.6.x/01a-python-to-synsema)
> — mapea los reflejos de Python a estas formas y marca las trampas semánticas (doctesteadas).

```synsema
-- Doc example: core syntax. Universal code; English comments.
intent: "doc example: variables, operators, pipe, inline conditional"

task double(n)
    give n * 2

print("5 |> double = " + text(5 |> double))    -- run shows: 5 |> double = 10

test "let / set / arithmetic"
    let x be 10
    set x to x + 5
    assert_eq(x, 15)
    assert_eq(10 % 3, 1)

test "comparison + boolean logic"
    assert(1 < 2 and 2 <= 2)
    assert(true or false)
    assert(not false)

test "pipe is unary application: x |> f == f(x)"
    assert_eq(5 |> double, 10)

test "inline conditional is an expression"
    let label be when 80 >= 50 then "pass" otherwise "fail"
    assert_eq(label, "pass")
```

## Variables

`let name be value` introduce una variable; `set name to value` la reasigna.

## Operadores

- Aritmética: `+` `-` `*` `/` `%` `**`. **La división es siempre float** (`10 / 3` → `3.333…`).
- Comparación: `==` `!=` `<` `>` `<=` `>=`.
- Lógica: `and` `or` `not`. **`and`/`or` cortocircuitan** (engine v0.6.10+): `contains(m, "k") and m["k"] == 1` es un guard válido — el índice no corre cuando `contains` es falso, y `or` saltea el lado derecho cuando el izquierdo ya es verdadero. El resultado siempre es un **bool**, nunca el operando: `x or "default"` es `true`/`false`, no el default (usá `when`). En engines ≤ 0.6.9 los dos lados se evaluaban siempre — ahí guardá con un `when` anidado.
- **El pipe `|>` es aplicación unaria**: `x |> f` significa `f(x)` (donde `f` es el nombre de una task o una lambda de un argumento). Para varios args, envolvé: `xs |> ((v) => f(v, extra))`.

## Condicional inline

`when cond then a otherwise b` es una **expresión** (usable dentro de `let`, un map o una llamada), distinta del `when` en bloque.

## Strings

- `"..."` / `'...'` — una línea, con escapes (`\n`, `\t`, `\"`). Un salto de línea literal adentro es error.
- `` `...` `` — multilínea + interpolación: `` `Hola {name}` `` evalúa `{expr}`. Ideal para SQL/HTML.

## Comentarios

`-- un comentario` va hasta el fin de línea.