# Aspectos Essenciais do FatScript  
Linguagem interpretada, concisa e com estilo funcional.  
Sintaxe explícita; projetada para aplicativos/scripts de console.

## Comentários
Apenas comentários de linha são suportados:
```
# comentário
```

## Imports
```
console <- fat.console
outro <- meuArquivo
```

## Bibliotecas Comuns
- `_ <- fat.std` adiciona todos os tipos nativos e bibliotecas padrão ao contexto: async, bridge, color, console, curses, enigma, failure, file, http, math, recode, sdk, smtp, socket, system, time
- `console.log` adiciona nova linha, `console.print` não, `console.input` exibe um prompt e lê a entrada
- `file.read(path)` le um arquive, `file.write(path, val)` escreve em um arquivo

## Constantes (`=`) e Variáveis (`~`) (camelCase)
```
name = 'Maria'
~ age = 25
```

## Lists (`[]`)
```
nums = [ 1, 2, 3 ]
nums(0)  # somente leitura
nums[0]  # somente para listas mutáveis
```

## Scopes/Objetos (`{}`)
```
user = { name='maria', age=30 }
user.name          # leitura/escrita
user('name')       # somente leitura
user['name']       # leitura/escrita
scope.valuesOf(T)  # extrai valores do tipo especificado
```

## Tipos (PascalCase)
Definem classes/tipos:
```
Person = (name: Text, ~age: Number, birthday = <> self.age += 1)
```

## Methods (`->`) e Procedures (`<>`) (camelCase)
```
saudar = (nome: Text) -> 'Olá, {nome}'
nomes = List <> usuarios @ -> _.nome
```

## Controle de Fluxo
```
val ?? fallback     # Coalescência nula
cond ? then : else  # If-Else
x => y              # Caso simples (match)
val >> { caso => resultado, _ => padrão }  # Switch
```

## Loops (`@`)
```
condition @ corpo                       # loop enquanto condition
1..10 @ n -> processar(n)               # n é um número do intervalo
list @ item -> processar(item)          # item é o valor
..<list.size @ i -> processar(list(i))  # i é o índice, list(i) é o valor
scope @ key -> usar(key)                # ou usar(scope(key)) para o valor
```

## Argumentos Implícitos (`_`)
```
dobro = -> _ * 2
```

## Tratamento de Erros
```
failure <- fat.failure
SubtypeError = Error
failure.trapWith(-> _ == SubtypeError ? tratador : _)
```

## Encadeamento de Métodos
```
nums.reduce(reducer, {}).valuesOf(Type).sortBy('key').map(-> _.value)
```

## Fatiamento e Intervalos
```
'hello'(1..)    # 'ello'
'hello'(1..<4)  # 'ell'
nums(-2..)      # últimos dois elementos
```

## Manipulação de Texto
```
text.split('')
list.join('')
```

## Operadores Lógicos
- `&` (AND)
- `|` (OR)
```
x > 0 & y < 5 | z == 10
```

## Convenções
- Sem operadores binários, apenas métodos explícitos
- Tipos em PascalCase, variáveis/métodos em camelCase
- Variáveis mutáveis devem ser declaradas explicitamente com `~`
- Comparações profundas por padrão