Tipos y datos

Valores base: text, number, bool, list, map y nothing. (Además decimal, bytes, complex y array numérico para trabajo científico — ver Stdlib.)

types.syn

-- Doc example: types, property access, custom types, intentional operations.
intent: "doc example: types and data"

type Point
    x: number
    y: number

let demo_p be Point(3, 4)
print("Point(3,4) → x=" + text(x of demo_p) + " y=" + text(y of demo_p))

test "values + property access (of / dot / index)"
    let cfg be {"host": "localhost", "port": 8080}
    assert_eq(port of cfg, 8080)
    assert_eq(cfg.host, "localhost")
    assert_eq(cfg["port"], 8080)
    assert_eq(length([1, 2, 3]), 3)

test "custom type + positional constructor"
    let p be Point(3, 4)
    assert_eq(x of p, 3)
    assert_eq(y of p, 4)

test "intentional ops replace loops"
    let nums be [1, 2, 3, 4]
    assert_eq(apply((n) => n * 2, nums), [2, 4, 6, 8])
    assert_eq(where(nums, (n) => n > 2), [3, 4])
    assert_eq(reduce(nums, (a, b) => a + b, 0), 10)
    assert_eq(sort_by([3, 1, 2], (v) => v), [1, 2, 3])

Acceso a propiedades — tres formas

host of config       -- natural
config.host          -- punto
config["host"]       -- índice

Tipos personalizados

Un type declara campos con nombre; el constructor es posicional en el orden de los campos:

type Customer
    name: text
    email: text
    balance: number

let c be Customer("Ada", "ada@x.com", 500)
let who be name of c

Operaciones intencionales (en vez de loops)

Expresá la intención y dejá que el runtime itere:

apply(fn, list) — transformar cada item.
where(list, predicado) — filtrar.
reduce(list, fn, inicial) — plegar a un valor.
sort_by(list, key_fn), collect(list, "campo"), count_where(list, predicado).

Se lee mejor que un loop, y es lo primero a lo que un LLM debería recurrir.