Potigol

01 · Visão geral

Sobre Potigol

Potigol é uma linguagem de programação educacional com sintaxe em português e recursos imperativos, funcionais e orientados a objetos. A documentação oficial destaca tipagem estática com inferência, funções, listas, tuplas, tipos próprios e casamento de padrões.

As construções desta página descrevem Potigol conforme as referências do projeto. Bibliotecas adicionais, como Jerimum, ampliam o que pode ser feito com a linguagem sem fazer parte de sua sintaxe central.

02 · Organização

Estrutura básica

Um arquivo pode começar diretamente com declarações e instruções. Não é necessário envolver todo o programa em um bloco programa ou declarar uma função principal para os exemplos simples.

# Uma sequência de instruções
nome = "Mundo"
escreva "Olá, {nome}!"

soma(a: Inteiro, b: Inteiro) = a + b
escreva soma(2, 3)

As instruções podem ser expressões, declarações, chamadas, atribuições ou blocos encerrados por fim. Funções e tipos também podem ser declarados no arquivo.

03 · Escrita

Nomes e comentários

• Identificadores começam com uma letra e podem conter letras, acentos, números e sublinhados.
• Palavras-chave e nomes de tipos aparecem em português, como se, então, Inteiro e Lógico.
• Comentários de linha começam com # e seguem até o fim da linha.
• Textos usam aspas duplas; expressões dentro de chaves podem ser interpoladas no texto.

# Comentário
aluna = "Lia"
nota = 8.5
escreva "{aluna} obteve {nota}"

04 · Dados

Tipos e variáveis

A atribuição com = cria um valor que não recebe novas atribuições. Use var para declarar uma variável que pode mudar; a atualização usa :=. O tipo é inferido quando não aparece explicitamente e não muda durante a execução.

pontos = 10
var tentativas := 0
tentativas := tentativas + 1

nome: Texto = "Lia"
idade: Inteiro = 14

A atribuição paralela permite associar vários valores em uma única instrução, por exemplo a, b = 3, 7.

05 · Expressões

Operadores

Parênteses deixam explícita a ordem desejada. Em expressões com listas, :: associa um item ao começo: 0 :: [1, 2] resulta em [0, 1, 2].

06 · Interação

Entrada e saída

escreva apresenta uma expressão e avança para a linha seguinte; imprima escreve sem essa quebra. As funções leia_inteiro, leia_numero e leia_texto leem valores do tipo indicado. A documentação também descreve leituras de vários valores e de listas.

imprima "Digite seu nome: "
nome = leia_texto
escreva "Olá, {nome}!"

escreva "Digite dois números:"
a, b = leia_inteiro
escreva "{a} + {b} = {a + b}"

Em uma cadeia, {expressão} interpola o valor no texto. Para valores formatados, Potigol também documenta a expressão valor formato padrão.

07 · Fluxo

Condições e repetições

se e escolha expressam decisões. Os blocos podem ser usados como instruções ou como expressões que produzem um valor.

mensagem = se nota >= 7 então
  "Aprovada"
senão
  "Continue praticando"
fim

escolha nota
  caso 10 => "Excelente"
  caso n se n >= 7 => "Aprovada"
  caso _ => "Estude mais"
fim

As repetições incluem para e enquanto. O para percorre um intervalo com início e fim ou os elementos de uma coleção; o passo pode ser indicado quando necessário.

para i de 1 até 3 faça
  escreva i
fim

var n := 3
enquanto n > 0 faça
  escreva n
  n := n - 1
fim

08 · Reuso

Funções e coleções

Uma função curta pode ser escrita como expressão. Funções com várias instruções terminam em fim; o valor final da expressão é retornado, ou pode ser indicado com retorne. Funções também aceitam parâmetros tipados e podem ser recursivas.

dobro(n: Inteiro) = n * 2

fatorial(n: Inteiro): Inteiro
  se n <= 1 então
    1
  senão
    n * fatorial(n - 1)
  fim
fim

Listas e tuplas organizam valores. Listas podem ser transformadas por operações como mapeie, filtradas com selecione e reduzidas com injete. A documentação de Potigol usa índices de lista iniciados em 1.

numeros = [1, 2, 3, 4]
dobros = numeros.mapeie(n => n * 2)
pares = numeros.selecione(n => n mod 2 == 0)
coordenada = (3.5, 2.0)

09 · Modelagem

Tipos compostos e orientação a objetos

O comando tipo declara estruturas com atributos e métodos. Um valor pode ser criado chamando o nome do tipo com os valores dos atributos; métodos acessam esses atributos e podem ser usados como propriedades ou funções.

tipo Pessoa
  nome: Texto
  saudacao() = "Olá, {nome}!"
fim

aluna = Pessoa("Lia")
escreva aluna.saudacao

Tuplas

Tuplas são coleções ordenadas, imutáveis e de tamanho fixo; seus elementos podem ter tipos diferentes. A posição tem significado estável, acessado por propriedades como .primeiro, .segundo e .terceiro.

ponto = (3.5, 4.2)
aluna = ("Lia", 14, 8.5)

escreva ponto.primeiro
escreva ponto.segundo
escreva aluna.terceiro

Use uma tupla para agrupar dados relacionados ou organizar vários valores produzidos por uma função. Para coleções homogêneas cujo tamanho pode variar, use uma lista.

A documentação oficial também apresenta tipos abstratos, herança, tipos genéricos, funções como valores e casamento de padrões.

10 · Operações integradas

Matemática e textos

Potigol oferece operações matemáticas para números e métodos para consultar ou transformar textos. Os nomes permanecem em português; confira o tipo de cada resultado antes de combiná-lo com outra expressão.

raio = 3.0
area = PI * raio ^ 2
frase = "lógica e programação"
partes = frase.divida(" ")

escreva "Área: {area}"
escreva "A frase tem {frase.tamanho} caracteres"
escreva partes

Textos também podem ser concatenados com +. As conversões .inteiro e .real interpretam o início de um texto numérico; para entradas livres, valide o valor antes de usá-lo em um cálculo.

11 · Coleções

Listas em detalhe

Uma lista mantém elementos em ordem e, por padrão, é imutável: operações como inserção, remoção e atualização produzem uma nova lista. Os índices começam em 1, ao contrário do padrão comum em outras pseudolinguagens documentadas aqui.

original = [2, 4, 6, 8]
var atualizada := original
atualizada[2] := 5

escreva original       # [2, 4, 6, 8]
escreva atualizada     # [2, 5, 6, 8]

A atribuição com := atualiza uma variável mutável, mas não altera a lista compartilhada em original. Os métodos .atualize, .insira e .remova tornam explícito que o resultado é uma nova lista.

12 · Abstração

Programação funcional

Uma função pode receber outra função como argumento ou devolvê-la como resultado. Expressões lambda, escritas com =>, descrevem operações curtas sem declarar uma função com nome.

numeros = [1, 2, 3, 4, 5, 6, 7, 8]
pares = numeros.selecione(n => n mod 2 == 0)
dobros = pares.mapeie(n => n * 2)
soma = numeros.injete(0)((total, n) => total + n)

aplique(f: Inteiro => Inteiro, valor: Inteiro) = f(valor)
sucessor(n: Inteiro) = n + 1
escreva aplique(sucessor, 5)

• selecione mantém os elementos que satisfazem uma condição.
• mapeie transforma cada elemento e devolve uma lista.
• injete percorre a coleção e combina seus elementos com um acumulador inicial.

Essas operações não mudam a lista de origem. O tipo dos parâmetros e do resultado da função ajuda a verificar se a transformação corresponde aos dados.

Compreensão de listas

Uma compreensão combina uma ou mais sequências de geração com uma expressão para produzir uma nova lista. Cada gerador pode depender dos valores anteriores.

somas = para i de 1 até 3,
             j de i + 1 até 3 gere
               i + j
         fim
escreva somas

Currying

Uma função curried recebe seus argumentos em etapas: cada chamada parcial devolve outra função. Isso permite guardar uma função já configurada para reutilizá-la.

soma(a: Inteiro) = ((b: Inteiro) => a + b)
soma_dois = soma(2)
escreva soma(2)(3)
escreva soma_dois(4)

Recursão em cauda

Na recursão em cauda, a chamada recursiva é a última operação do caso. A documentação de Potigol apresenta essa forma com otimização, adequada a percursos recursivos que carregam um acumulador.

conta(n: Inteiro, acumulado: Inteiro): Inteiro = escolha n
  caso 0 => acumulado
  caso restante => conta(restante - 1, acumulado + 1)
fim

escreva conta(1000, 0)

13 · Decisão por forma

Casamento de padrões

escolha pode comparar um valor com casos ou examinar a estrutura de uma lista. O padrão [] representa uma lista vazia; cabeça :: cauda separa o primeiro elemento do restante. Um padrão _ aceita qualquer valor, e uma condição adicional pode restringir um caso.

quantidade(itens: Lista[Inteiro]): Inteiro = escolha itens
  caso [] => 0
  caso _ :: restante => 1 + quantidade(restante)
fim

classifique(n: Inteiro) = escolha n
  caso valor se valor < 0 => "negativo"
  caso 0 => "zero"
  caso _ => "positivo"
fim

escreva quantidade([3, 5, 8])
escreva classifique(-2)

Os casos são avaliados na ordem em que aparecem; coloque os padrões mais específicos antes de um caso amplo como _. Em funções recursivas, o caso vazio fornece a condição de parada.

14 · Biblioteca de jogos

Jerimum: jogos com Potigol

Jerimum é uma biblioteca de jogos para Potigol. O repositório oficial organiza exemplos e módulos para criar uma janela, desenhar imagens e textos, ler teclado e mouse, controlar o tempo e reproduzir áudio. Ela acrescenta recursos de jogo ao programa Potigol; não é parte da sintaxe central documentada acima.

Início e ciclo do jogo

Um programa que usa Jerimum começa com use "jerimum" e define duas funções sem parâmetros: atualize(), para atualizar o estado do jogo, e desenhe(), para registrar o que aparece na tela. jogo.iniciar recebe título, largura, altura, as duas funções e, opcionalmente, a taxa de quadros, cujo valor padrão é 60.

use "jerimum"

atualize()
  # Atualize as posições e o estado
fim

desenhe()
  # Registre as imagens e textos do quadro
fim

jogo.iniciar("Meu jogo", 640, 480, atualize, desenhe, 60)

O módulo jogo expõe largura, altura, título e fps. A janela é criada pelo código da biblioteca com Swing/AWT e dimensões fixas. As funções Jogo.distância, Jogo.projeção_X e Jogo.projeção_Y ajudam em cálculos de movimento; os ângulos das projeções são informados em graus.

Desenho, camadas e imagens

Imagens são carregadas com Imagem("arquivo.png"). O método desenhe(x, y, z) posiciona a imagem usando coordenadas e uma camada inteira. Camadas com números maiores são desenhadas à frente das menores; a camada zero pode servir como fundo. Também há desenho centralizado, rotação, escala e recorte de folhas de sprites com fatie.

fundo = Imagem("fundo.png")
nave = Imagem("nave.png")
quadros = Imagem.fatie("explosao.png", 32, 32)

desenhe()
  fundo.desenhe(0, 0, 0)
  nave.desenhe_centralizado(320, 240, 2, 0)
fim

Animacao(velocidade, imagens) seleciona imagens de uma sequência conforme o tempo decorrido. A documentação de exemplos mostra a divisão de uma folha de sprites em quadros e o uso de um quadro por atualização.

Teclado, mouse e tempo

Teclado disponibiliza valores lógicos como TECLA_PARA_DIREITA, TECLA_PARA_CIMA, TECLA_ENTER e TECLA_A a TECLA_Z. Mouse.x e Mouse.y informam a posição; Mouse.BOTAO_ESQUERDO e Mouse.BOTAO_DIREITO indicam se esses botões estão pressionados. Relógio.milisegundos conta o tempo desde a inicialização do módulo.

var x := 100

atualize()
  se Teclado.TECLA_PARA_DIREITA então
    x := x + 4
  fim
  se Mouse.BOTAO_ESQUERDO então
    x := Mouse.x
  fim
fim

Texto, cores, áudio e arquivos

Fonte(tamanho) cria uma fonte; desenhe e desenhe_centralizado colocam texto em uma camada e aceitam uma cor. Cor(vermelho, verde, azul) recebe componentes RGB inteiros e há constantes como Cor.BRANCO, Cor.PRETO e Cor.VERDE.

Som("efeito.wav") reproduz um efeito com toque() e pode ser interrompido com pare. Musica("faixa.wav") oferece toque, pause, continue, pare e tocando; a reprodução começa em loop por padrão. Arquivo.leia("dados.txt") devolve uma lista com as linhas do arquivo.

Exemplo: mover uma imagem

use "jerimum"

nave = Imagem("nave.png")
var x := 300
var y := 220

atualize()
  se Teclado.TECLA_PARA_DIREITA então x := x + 4 fim
  se Teclado.TECLA_PARA_ESQUERDA então x := x - 4 fim
  se Teclado.TECLA_PARA_CIMA então y := y - 4 fim
  se Teclado.TECLA_PARA_BAIXO então y := y + 4 fim
fim

desenhe()
  nave.desenhe_centralizado(x, y, 1)
fim

jogo.iniciar("Movimento", 640, 480, atualize, desenhe)

Os detalhes de cada método estão na documentação e no código-fonte do repositório Jerimum. Essa biblioteca usa recursos da plataforma Java para janela, desenho e áudio; seus exemplos devem ser lidos como aplicações para desktop Potigol.

15 · Exemplo integrado

Calcular a média de três notas

Este exemplo combina entrada tipada, função, condição e interpolação:

media(a: Real, b: Real, c: Real) = (a + b + c) / 3

escreva "Digite três notas:"
a, b, c = leia_numero
resultado = media(a, b, c)

se resultado >= 7 então
  escreva "Aprovada: {resultado}"
senão
  escreva "Em recuperação: {resultado}"
fim

16 · Leitura adicional

Referências

• Documentação oficial de Potigol, incluindo tópicos de sintaxe, estruturas, funções, tipos, listas e tuplas.
• Referências oficiais de números, textos, matemática e funções.
• Referências oficiais de listas, tuplas e programação funcional, com compreensão de listas, funções lambda, currying, recursão em cauda e casamento de padrões.
• Repositório oficial de Potigol e gramática publicada.
• Repositório oficial de Jerimum, com documentação e exemplos.
• Referências de Jogo, Imagem, Teclado, Mouse, Fonte e Cor; o código-fonte também documenta áudio, animação e leitura de arquivos.