---
slug: 11-types
title: Tipos y datos
description: Valores de Synsema, acceso a propiedades (of / dot / índice), tipos personalizados y las operaciones intencionales que reemplazan los loops.
example_ids: [types]
---

# 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.)

```synsema
-- 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

```synsema
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:

```synsema
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.