---
slug: 12-tasks-lambdas
title: Tasks y lambdas
description: Definí tasks con give, argumentos por defecto y con nombre, recursión, y lambdas de primera clase pasadas a operaciones de orden superior.
example_ids: [tasks]
---

# Tasks y lambdas

Una `task` es una función: parámetros, un cuerpo y `give` para devolver un valor.

```synsema
-- Doc example: tasks, default args, named args, recursion, lambdas.
intent: "doc example: tasks and lambdas"

task add(a, b)
    give a + b

task greet(name, greeting = "Hello")
    give greeting + ", " + name + "!"

task factorial(n)
    when n <= 1
        give 1
    otherwise
        give n * factorial(n - 1)

print(greet("Ada") + "  factorial(5) = " + text(factorial(5)))    -- run shows the result

test "call, default arg, named arg"
    assert_eq(add(2, 3), 5)
    assert_eq(greet("Ada"), "Hello, Ada!")
    assert_eq(greet("Ada", "Hi"), "Hi, Ada!")
    assert_eq(greet("Ada", greeting = "Hey"), "Hey, Ada!")

test "recursion"
    assert_eq(factorial(5), 120)

test "lambdas are values, passed to higher-order tasks"
    let triple be (n) => n * 3
    assert_eq(triple(4), 12)
    assert_eq(apply(triple, [1, 2, 3]), [3, 6, 9])
```

## Argumentos por defecto y con nombre

```synsema
task greet(name, greeting = "Hello")
    give greeting + ", " + name + "!"

greet("Ada")                    -- usa el default
greet("Ada", "Hi")              -- posicional
greet("Ada", greeting = "Hey")  -- con nombre (en cualquier orden)
```

El valor por defecto (`= expr`) se evalúa al llamar. Ojo: `=` acá es la forma de **argumento** — la asignación general es `let`/`set`, y la igualdad es `==`.

## Recursión

Una task puede llamarse a sí misma (`factorial` arriba). No hay keyword especial — solo `give`.

## Lambdas

Una lambda es un valor: `(params) => expr`. Guardala, pasala, o dásela a una operación de orden superior:

```synsema
let triple be (n) => n * 3
apply(triple, [1, 2, 3])        -- [3, 6, 9]
where(items, (x) => x.active)   -- predicado inline
```