🌵 Cangaceiro — A Linguagem de Programação Brasileira

  ██████╗ █████╗ ███╗   ██╗ ██████╗  █████╗  ██████╗███████╗██╗██████╗  ██████╗ 
 ██╔════╝██╔══██╗████╗  ██║██╔════╝ ██╔══██╗██╔════╝██╔════╝██║██╔══██╗██╔═══██╗
 ██║     ███████║██╔██╗ ██║██║  ███╗███████║██║     █████╗  ██║██████╔╝██║   ██║
 ██║     ██╔══██║██║╚██╗██║██║   ██║██╔══██║██║     ██╔══╝  ██║██╔══██╗██║   ██║
 ╚██████╗██║  ██║██║ ╚████║╚██████╔╝██║  ██║╚██████╗███████╗██║██║  ██║╚██████╔╝
  ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝╚══════╝╚═╝╚═╝  ╚═╝ ╚═════╝ 

A linguagem de programação feita no Brasil, pro Brasil, com o coração do Brasil. Oxente! 🤠

Cangaceiro é uma linguagem transpilada para JavaScript/Node.js, com sintaxe totalmente em português brasileiro usando as gírias e expressões do nosso povo. Arquivos com extensão .cgr.

Instalação

npm install -g cangaceiro-lang

Pronto! Agora você tem os comandos cangaceiro e cgr disponíveis.

Primeiro programa

Crie um arquivo ola.cgr:

grita("Oxente! Olá, Mundo! 🌵")
grita("Vamo que vamo, rapaiz!")

Execute:

cangaceiro rodar ola.cgr
# ou usando o atalho:
cgr rodar ola.cgr

Saída:

Oxente! Olá, Mundo! 🌵
Vamo que vamo, rapaiz!

Comandos da CLI

| Comando | O que faz | |---|---| | cangaceiro rodar arquivo.cgr | Executa um arquivo Cangaceiro | | cangaceiro converter arquivo.cgr | Converte para JS e mostra na tela | | cangaceiro salvar arquivo.cgr | Converte e salva como .js | | cangaceiro novo meu_projeto | Cria estrutura de projeto novo | | cangaceiro ajuda | Mostra ajuda | | cangaceiro versao | Mostra a versão |

Flags disponíveis:

• --verbose — Mostra o JavaScript gerado antes de executar
• --sem-cores — Desativa cores no terminal

Manual Completo da Linguagem

1. Comentários

-- Isso é um comentário de linha (dois traços)

{-
  Isso é um comentário
  de múltiplas linhas
  Oxente, que prático!
-}

2. Variáveis

Cangaceiro tem três formas de declarar variáveis:

| Cangaceiro | JavaScript | Quando usar | |---|---|---| | firme | const | Valor que não muda | | bora | let | Valor que pode mudar | | deixa | var | Escopo de função (legado) |

-- Constante: use 'firme' quando o valor não vai mudar
firme pi = 3.14159
firme nome = "Maria Bonita"
firme ativo = verdade

-- Variável mutável: use 'bora' quando vai mudar
bora pontos = 0
bora tentativas = 3

pontos += 100
tentativas--

grita(pontos)      -- 100
grita(tentativas)  -- 2

3. Tipos de Dados

Números

firme inteiro = 42
firme decimal = 3.14
firme negativo = -7
firme grande = 1_000_000   -- underscore para legibilidade

Textos (Strings)

firme simples = "Oxente, Brasil!"
firme aspas_simples = 'Também funciona!'

-- Template strings (interpolação) com acento grave
firme cidade = "Fortaleza"
firme mensagem = `Vivo em ${cidade}, arretado!`
grita(mensagem)   -- Vivo em Fortaleza, arretado!

-- Expressões dentro do template
firme a = 10
firme b = 5
grita(`${a} + ${b} = ${a + b}`)   -- 10 + 5 = 15

Booleanos

firme verdadeiro = verdade   -- true
firme falso = mentira        -- false

Nulo e Indefinido

firme vazio = nada        -- null
firme desconhecido = sei_la   -- undefined

Verificação de tipo

grita(tipo_de "texto")    -- string
grita(tipo_de 42)         -- number
grita(tipo_de verdade)    -- boolean
grita(tipo_de nada)       -- object

4. Operadores

Aritméticos

firme a = 10
firme b = 3

grita(a + b)    -- 13  (soma)
grita(a - b)    -- 7   (subtração)
grita(a * b)    -- 30  (multiplicação)
grita(a / b)    -- 3.333... (divisão)
grita(a % b)    -- 1   (resto)
grita(a ** b)   -- 1000 (potência)

Atribuição

bora x = 10
x += 5    -- 15
x -= 3    -- 12
x *= 2    -- 24
x /= 4    -- 6
x++       -- 7
x--       -- 6

Comparação

grita(5 == "5")    -- verdade (igualdade fraca)
grita(5 === "5")   -- mentira (igualdade estrita)
grita(5 !== "5")   -- verdade
grita(10 > 5)      -- verdade
grita(5 >= 5)      -- verdade

Lógicos

-- 'tambem' é o && (E lógico)
grita(verdade tambem verdade)   -- verdade
grita(verdade tambem mentira)   -- mentira

-- 'ou' é o || (OU lógico)
grita(mentira ou verdade)   -- verdade

-- 'nao' é o ! (NÃO lógico)
grita(nao verdade)   -- mentira

Operadores especiais

-- Nullish coalescing (??)
firme nome = nada
grita(nome ?? "Visitante")   -- Visitante

-- Optional chaining (?.)
firme usuario = nada
firme cidade = usuario?.perfil?.cidade
grita(cidade)   -- sei_la (sem erro!)

-- Ternário
firme nota = 7
firme resultado = nota >= 6 ? "Passou!" : "Chumbou!"

-- Spread (...)
firme lista1 = [1, 2, 3]
firme lista2 = [...lista1, 4, 5, 6]

-- Instanceof
firme arr = [1, 2, 3]
grita(arr e_do_tipo Array)   -- verdade

5. Condicionais

firme temp = 38

sefor (temp > 40) {
  grita("Oxente, que calor danado!")
} senaosefor (temp > 30) {
  grita("Tá quente, beba água!")
} senaosefor (temp > 20) {
  grita("Temperatura agradável.")
} senao {
  grita("Tá fresquinho hoje!")
}

Switch com depende / caso / padrao

firme dia = "sexta"

depende (dia) {
  caso "segunda":
    grita("Começo de semana...")
    fora
  caso "sexta":
    grita("Sextou! 🎉")
    fora
  caso "sabado":
  caso "domingo":
    grita("Final de semana!")
    fora
  padrao:
    grita("Dia comum.")
}

6. Laços de Repetição

enquanto (while)

bora i = 0
enquanto (i < 5) {
  grita(i)
  i++
}

repete — for clássico

repete (bora i = 0; i < 5; i++) {
  grita(`Número: ${i}`)
}

repete / dentro — for...of (itera valores)

firme frutas = ["manga", "cajá", "umbu"]

repete (fruta dentro frutas) {
  grita(`Fruta: ${fruta}`)
}

repete / dento — for...in (itera chaves)

firme pessoa = { nome: "João", cidade: "Recife" }

repete (chave dento pessoa) {
  grita(`${chave}: ${pessoa[chave]}`)
}

pula (continue) e para/fora (break)

repete (bora i = 0; i < 10; i++) {
  sefor (i === 5) { para }
  sefor (i % 2 === 0) { pula }
  grita(i)   -- imprime 1, 3
}

7. Funções

Declaração com manda

manda soma(a, b) {
  volta a + b
}

grita(soma(3, 4))   -- 7

Parâmetros padrão

manda cumprimento(nome, saudacao = "Oxente") {
  grita(`${saudacao}, ${nome}!`)
}

cumprimento("Maria")           -- Oxente, Maria!
cumprimento("José", "E aí")    -- E aí, José!

Arrow functions

firme dobra = (n) => n * 2
firme quadrado = (n) => n * n

-- Com corpo
firme saudacao = (nome) => {
  volta `Boa tarde, ${nome}!`
}

Rest parameters

manda soma_tudo(...numeros) {
  volta reduz(numeros, (acc, n) => acc + n, 0)
}

grita(soma_tudo(1, 2, 3, 4, 5))   -- 15

Closures e funções de ordem superior

manda somador(x) {
  volta (y) => x + y
}

firme soma5 = somador(5)
grita(soma5(3))    -- 8
grita(soma5(10))   -- 15

Funções assíncronas

espera manda busca_usuario(id) {
  aguenta espera_ai(500)
  volta { id, nome: "Fulano" }
}

espera manda principal() {
  firme usuario = aguenta busca_usuario(42)
  grita("Usuário:", usuario)
}

principal()

8. Classes e Objetos

tipo Pessoa {
  construtor(nome, idade) {
    esse.nome = nome
    esse.idade = idade
  }

  apresenta() {
    grita(`Oi! Sou ${esse.nome}, tenho ${esse.idade} anos.`)
  }

  faz_aniversario() {
    esse.idade++
  }
}

firme maria = novo Pessoa("Maria", 25)
maria.apresenta()

Herança com herda

tipo Animal {
  construtor(nome, som) {
    esse.nome = nome
    esse.som = som
  }

  fala() {
    grita(`${esse.nome} faz: ${esse.som}!`)
  }
}

tipo Cachorro herda Animal {
  construtor(nome) {
    super(nome, "Au au")
  }

  busca(objeto) {
    grita(`${esse.nome} trouxe o ${objeto}!`)
  }
}

firme rex = novo Cachorro("Rex")
rex.fala()
rex.busca("bola")
grita(rex e_do_tipo Animal)   -- verdade

9. Listas (Arrays)

firme frutas = ["manga", "caju", "umbu"]

-- Acesso e tamanho
grita(frutas[0])           -- manga
grita(tamanho(frutas))     -- 3

-- Funções de lista
firme pares = filtra([1,2,3,4,5], (n) => n % 2 === 0)
grita(pares)   -- [2, 4]

firme dobrados = mapeia([1,2,3], (n) => n * 2)
grita(dobrados)   -- [2, 4, 6]

firme total = reduz([1,2,3,4,5], (acc, n) => acc + n, 0)
grita(total)   -- 15

-- Outros
grita(tem(frutas, "manga"))         -- verdade
grita(inverte([1, 2, 3]))           -- [3, 2, 1]
grita(parte([1,2,3,4,5], 1, 3))     -- [2, 3]
grita(junta(frutas, " | "))         -- manga | caju | umbu

-- Spread
firme mais = [...frutas, "tamarindo"]

10. Objetos

firme pessoa = {
  nome: "Luzia",
  idade: 30,
  cidade: "Salvador"
}

-- Acesso
grita(pessoa.nome)
grita(pessoa["cidade"])

-- Utilitários
grita(chaves(pessoa))     -- ['nome', 'idade', 'cidade']
grita(valores(pessoa))    -- ['Luzia', 30, 'Salvador']

-- Mesclar e copiar
firme base = { x: 1, y: 2 }
firme extra = { z: 3 }
firme completo = mistura({}, base, extra)

-- Spread de objeto
firme atualizado = { ...pessoa, cidade: "Recife" }

11. Desestruturação

De listas

firme cores = ["vermelho", "verde", "azul"]
firme [primeira, segunda] = cores

-- Com rest
firme [cabeca, ...resto] = cores

De objetos

firme config = { host: "localhost", porta: 3000 }
firme { host, porta } = config

-- Renomeando
firme { host: servidor } = config

-- Com padrão
firme { debug = mentira } = config

Em parâmetros

manda exibe({ nome, idade, cidade = "Desconhecida" }) {
  grita(`${nome}, ${idade} anos, de ${cidade}`)
}

12. Tratamento de Erros

tenta {
  firme resultado = divisao(10, 0)
} errou (err) {
  grita("Deu ruim:", err.message)
} porvia {
  grita("Isso roda sempre!")
}

-- Lançar erros
manda divisao(a, b) {
  sefor (b === 0) {
    joga novo erro("Divisão por zero, rapaiz!")
  }
  volta a / b
}

13. Programação Assíncrona

espera manda busca(url) {
  firme resposta = aguenta fetch(url)
  firme dados = aguenta resposta.json()
  volta dados
}

espera manda principal() {
  tenta {
    firme dados = aguenta busca("https://api.exemplo.com/dados")
    grita(dados)
  } errou (err) {
    grita("Erro:", err.message)
  }
}

principal()

Promise.all

espera manda carrega_tudo() {
  firme [usuarios, produtos] = aguenta promessa.all([
    busca("/usuarios"),
    busca("/produtos")
  ])
  grita(usuarios, produtos)
}

14. Módulos

-- Importar
puxa express de 'express'
puxa { useState, useEffect } de 'react'

-- Exportar
manda_pra manda soma(a, b) {
  volta a + b
}

manda_pra tipo Calculadora {
  construtor() { esse.valor = 0 }
}

firme PI = 3.14159
manda_pra { PI }

15. Funções Built-in

Saída

| Função | O que faz | |---|---| | grita(...) | console.log(...) | | grita_erro(...) | console.error(...) | | grita_aviso(...) | console.warn(...) |

Entrada (async)

| Função | O que faz | |---|---| | aguenta pergunta("msg") | Lê linha do terminal |

Matemática

| Função | O que faz | |---|---| | aleatorio(min, max) | Número decimal aleatório | | aleatorio_inteiro(min, max) | Inteiro aleatório | | arredonda(n) | Math.round | | piso(n) | Math.floor | | teto(n) | Math.ceil | | raiz(n) | Math.sqrt | | potencia(b, e) | Math.pow | | absoluto(n) | Math.abs | | maior(a, b, ...) | Math.max | | menor(a, b, ...) | Math.min | | PI | 3.14159... | | INFINITO | Infinity |

Verificação

| Função | O que faz | |---|---| | eh_numero(v) | É número? | | eh_texto(v) | É string? | | eh_lista(v) | É array? | | eh_funcao(v) | É função? | | tem_valor(v) | Não é null/undefined? | | nao_tem(v) | É null ou undefined? |

Listas

| Função | O que faz | |---|---| | tamanho(v) | .length | | tem(lista, item) | .includes() | | junta(lista, sep) | .join() | | parte(lista, i, f) | .slice() | | inverte(lista) | Inverte (imutável) | | ordena(lista, fn) | .sort() (imutável) | | filtra(lista, fn) | .filter() | | mapeia(lista, fn) | .map() | | reduz(lista, fn, i) | .reduce() | | achado(lista, fn) | .find() | | conta_items(lista, fn) | Conta que passam no filtro | | todo(lista, fn) | .every() | | algum(lista, fn) | .some() |

Objetos

| Função | O que faz | |---|---| | chaves(obj) | Object.keys() | | valores(obj) | Object.values() | | entradas(obj) | Object.entries() | | mistura(dest, ...) | Object.assign() | | congela(obj) | Object.freeze() | | copia(obj) | Deep clone via JSON |

Data e tempo

| Função | O que faz | |---|---| | agora() | Date.now() | | data_hoje() | new Date() | | formata_data(d) | Data em pt-BR | | espera_ai(ms) | Delay async em ms |

16. Tabela Completa de Palavras-chave

| Cangaceiro | JavaScript | Descrição | |---|---|---| | bora | let | Variável mutável | | firme | const | Constante | | deixa | var | Var de função | | manda | function | Declara função | | volta | return | Retorna valor | | sefor | if | Condicional | | senao | else | Senão | | senaosefor | else if | Senão se | | depende | switch | Escolha múltipla | | caso | case | Caso | | padrao | default | Padrão | | fora | break | Para switch/loop | | enquanto | while | Loop while | | repete | for | Loop for | | dentro | of | for...of | | dento | in | for...in | | pula | continue | Pula iteração | | para | break | Para loop | | tipo | class | Declara classe | | herda | extends | Herança | | novo | new | Cria instância | | esse | this | Referência ao objeto | | super | super | Classe pai | | espera | async | Função assíncrona | | aguenta | await | Aguarda promise | | promessa | Promise | Promise | | puxa | import | Importa módulo | | manda_pra | export | Exporta | | de | from | De qual módulo | | tenta | try | Tenta executar | | errou | catch | Captura erro | | porvia | finally | Executa sempre | | joga | throw | Lança erro | | erro | Error | Classe de erro | | verdade | true | Verdadeiro | | mentira | false | Falso | | nada | null | Nulo | | sei_la | undefined | Indefinido | | tambem | && | E lógico | | ou | \|\| | OU lógico | | nao | ! | NÃO lógico | | tipo_de | typeof | Tipo do valor | | e_do_tipo | instanceof | Verifica instância | | apaga | delete | Remove propriedade | | oxente | debugger | Breakpoint |

Exemplos Completos

FizzBuzz Brasileiro

repete (bora i = 1; i <= 20; i++) {
  sefor (i % 15 === 0) {
    grita("OxenteCaramelo!")
  } senaosefor (i % 3 === 0) {
    grita("Oxente!")
  } senaosefor (i % 5 === 0) {
    grita("Caramelo!")
  } senao {
    grita(i)
  }
}

Jogo de adivinhação

espera manda jogar() {
  firme secreto = aleatorio_inteiro(1, 100)
  bora tentativas = 0
  bora acertou = mentira

  grita("Pensei num número entre 1 e 100!")

  enquanto (nao acertou) {
    firme entrada = aguenta pergunta("Seu palpite: ")
    firme palpite = pra_numero(entrada)
    tentativas++

    sefor (palpite < secreto) {
      grita("Mais alto, rapaiz!")
    } senaosefor (palpite > secreto) {
      grita("Mais baixo, oxente!")
    } senao {
      acertou = verdade
      grita(`Arrepiou! Acertou em ${tentativas} tentativa(s)!`)
    }
  }
}

jogar()

API REST com Express

puxa express de 'express'

firme app = express()
app.use(express.json())

bora usuarios = [
  { id: 1, nome: "Maria", cidade: "Fortaleza" },
  { id: 2, nome: "João", cidade: "Recife" }
]

app.get('/usuarios', (req, res) => {
  res.json(usuarios)
})

app.get('/usuarios/:id', (req, res) => {
  firme usuario = achado(usuarios, (u) => u.id === pra_numero(req.params.id))
  sefor (nao_tem(usuario)) {
    res.status(404).json({ erro: "Usuário não encontrado!" })
    volta
  }
  res.json(usuario)
})

app.listen(3000, () => {
  grita("Servidor na porta 3000! Vamo que vamo!")
})

Uso programático (Node.js)

const { transpila, executa, carrega } = require('cangaceiro-lang');

// Converte para JavaScript
const js = transpila(`
  firme x = 42
  grita("O valor é:", x)
`);

// Executa diretamente
executa(`
  manda oi(nome) { grita("Oxente,", nome) }
  oi("Mundo")
`);

// Carrega arquivo .cgr
carrega('./meu_programa.cgr');

Licença

MIT — Use à vontade, rapaiz! 🌵

Feito com amor e muito cangaço no Brasil 🤠