---
title: "Una: o agente escreve, o Una verifica"
url: https://una-lang.org/pt-br/
release: v0.4.0
---

# Una

> Seu agente de IA escreve o código. Una prova que ele cumpre os contratos antes de rodar. Uma linguagem com autoridade declarada e saída em JSON para agentes.

O agente escreve. O Una verifica.

Seu agente escreve o código. O Una prova o contrato declarado de cada função para toda entrada, ou mostra a entrada que o quebra; o que ele não consegue decidir é erro, nunca aprovação. O que uma função pode tocar, como arquivos, a rede ou dados sensíveis, também está no cabeçalho.

## Uma volta do ciclo

1. O agente escreve. Seu agente escreveu esta função. Ela parece certa, e um teste com 5 ou 50 itens passaria.

```una
pub kind Availability = SoldOut | Few | Open

--- How much of an item is left to sell.
pub availability(remaining: Int) -> Availability
  requires remaining >= 0
  ensures remaining == 0 implies result is SoldOut
=
  if remaining < 20 then Few else Open
```

2. O Una refuta.

```text
$ una check stock.una   # trimmed
[U5001] postcondition of `availability` is refuted
counterexample: remaining = 0, result = Few
repair 1: add a guard or an arm so that the failing path returns a value for which `remaining == 0 implies result is SoldOut` holds
```

3. O agente conserta. O agente aplica o reparo 1: uma guarda para a entrada que o contraexemplo aponta.

```una
  if remaining == 0 then SoldOut else if remaining < 20 then Few else Open
```

4. Provado. Nada impresso, saída 0. A promessa agora vale para todo `remaining >= 0`, não só para as entradas que um teste tentou.

```text
$ una --json check stock.una
{"schema":"una.diagnostics/1","diagnostics":[],"fixable":0}
```

O Una prova que o código corresponde ao que você declarou. Declarar a coisa certa continua sendo com você.

## O que o Una verifica, e o que ele avisa que não verificou.

- Contratos: Pré-condições, pós-condições e tipos refinados são provados antes de o programa rodar. Uma prova que falha, ou que o provador não consegue concluir, é um erro e nunca um sucesso.
- Autoridade: Cada função pública declara as capacidades e operações que usa, e o Una infere e verifica as demais. Um programa só recebe autoridade do host por concessões: as que seu pacote declara e as dadas na linha de comando para uma execução.
- Fluxo de informação: Os rótulos acompanham os dados por atribuições e condições. Um valor rotulado como secreto só chega a um lugar menos restrito por uma política declarada, que o relatório de build lista.
- Interface para agentes: Todo comando, exceto o servidor de linguagem, devolve JSON com esquema: códigos de diagnóstico, posições exatas e, quando existem, reparos ordenados que um agente pode aplicar.

## Comece de onde você está.

```sh
curl -fsSL https://raw.githubusercontent.com/una-lang/una/main/install.sh | sh
export PATH="$HOME/.una/bin:$PATH"
una explain U5001
```

- [Em cinco minutos: Instale o Una, escreva um contrato, veja-o falhar, conserte.](https://una-lang.org/en/docs/get-started.md)
- [Com o seu agente: Dê ao seu agente a linguagem em uma página e o ciclo a rodar.](https://una-lang.org/en/docs/agents/compact.md)
- [Do começo: Una by Example: programas pequenos e completos, uma ideia por página.](https://una-lang.org/en/learn.md)
- [Guia da linguagem](https://una-lang.org/en/docs/language.md)
- [Diagnósticos](https://una-lang.org/en/docs/errors.md)

O Una é um beta de pesquisa e não está pronto para produção. Comentários são bem-vindos.
