Potigol

01 · Visión general

Sobre Potigol

Potigol es un lenguaje de programación educativo con sintaxis en portugués y recursos imperativos, funcionales y orientados a objetos. La documentación oficial destaca el tipado estático con inferencia, las funciones, listas, tuplas, tipos propios y el emparejamiento de patrones.

Las construcciones de esta página describen Potigol según las referencias del proyecto. Bibliotecas adicionales, como Jerimum, amplían lo que se puede hacer sin formar parte de su sintaxis central.

02 · Organización

Estructura básica

Un archivo puede comenzar directamente con declaraciones e instrucciones. Los ejemplos sencillos no necesitan un bloque externo ni una función principal.

# Una secuencia de instrucciones
nome = "Mundo"
escreva "Olá, {nome}!"

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

Las instrucciones pueden ser expresiones, declaraciones, llamadas, asignaciones o bloques que terminan en fim. También se pueden declarar funciones y tipos en el archivo.

03 · Escritura

Nombres y comentarios

• Los identificadores empiezan con una letra y pueden contener letras, acentos, números y guiones bajos.
• Las palabras reservadas y los tipos usan términos en portugués, como se, então, Inteiro y Lógico.
• Los comentarios de línea empiezan con #.
• Los textos usan comillas dobles; las expresiones entre llaves se interpolan en el texto.

# Comentario
aluna = "Lia"
nota = 8.5
escreva "{aluna} obteve {nota}"

04 · Datos

Tipos y variables

La asignación con = crea un valor que no recibe nuevas asignaciones. Usa var para declarar una variable modificable y := para actualizarla. El tipo se infiere si no se escribe y no cambia durante la ejecución.

pontos = 10
var tentativas := 0
tentativas := tentativas + 1
nome: Texto = "Lia"
idade: Inteiro = 14

La asignación paralela asocia varios valores en una instrucción, por ejemplo a, b = 3, 7.

05 · Expresiones

Operadores

Los paréntesis hacen explícito el orden. :: asocia un elemento al principio: 0 :: [1, 2] produce [0, 1, 2].

06 · Interacción

Entrada y salida

escreva muestra una expresión y pasa a la línea siguiente; imprima escribe sin ese salto. leia_inteiro, leia_numero y leia_texto leen valores del tipo indicado. La documentación también describe lecturas múltiples y 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}"

En una cadena, {expresión} inserta el valor en el texto. Potigol también documenta el formato con la expresión valor formato padrão.

07 · Flujo

Condiciones y repeticiones

se y escolha expresan decisiones. Los bloques pueden usarse como instrucciones o como expresiones que producen un 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

Las repeticiones incluyen para y enquanto. para recorre un intervalo o los elementos de una colección, y puede recibir un paso.

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 · Reutilización

Funciones y colecciones

Una función corta puede escribirse como expresión. Las funciones con varias instrucciones terminan en fim; el valor de la última expresión se devuelve, o se indica con retorne. También admiten parámetros tipados y recursión.

dobro(n: Inteiro) = n * 2

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

Las listas y tuplas organizan valores. Las listas se pueden transformar con mapeie, filtrar con selecione y reducir con injete. La documentación inicia los índices de las listas en 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 · Modelado

Tipos compuestos y orientación a objetos

tipo declara estructuras con atributos y métodos. Se crea un valor llamando al tipo con los valores de sus atributos; los métodos pueden usarse como propiedades o funciones.

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

Tuplas

Las tuplas son colecciones ordenadas, inmutables y de tamaño fijo; sus elementos pueden tener tipos distintos. Cada posición tiene un significado estable y se consulta con propiedades como .primeiro, .segundo y .terceiro.

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

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

Usa una tupla para agrupar datos relacionados u organizar varios valores producidos por una función. Para colecciones homogéneas cuyo tamaño puede variar, usa una lista.

La documentación oficial también trata tipos abstractos, herencia, genéricos, funciones como valores y emparejamiento de patrones.

10 · Operaciones integradas

Matemáticas y textos

Potigol ofrece operaciones matemáticas para números y métodos para consultar o transformar textos. Los nombres permanecen en portugués; comprueba el tipo de cada resultado antes de combinarlo con otra expresión.

raio = 3.0
area = PI * raio ^ 2
frase = "lógica e programación"
partes = frase.divida(" ")

escreva "Área: {area}"
escreva "La frase tiene {frase.tamanho} caracteres"
escreva partes

Los textos también pueden concatenarse con +. Las conversiones .inteiro y .real interpretan el inicio de un texto numérico; valida los datos de entrada antes de usarlos en un cálculo.

11 · Colecciones

Listas en detalle

Una lista mantiene sus elementos en orden y, por defecto, es inmutable: insertar, quitar o actualizar produce otra lista. Los índices empiezan en 1, a diferencia del patrón habitual en otros pseudolenguajes documentados aquí.

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

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

:= actualiza una variable mutable, pero no modifica la lista referenciada por original. Los métodos .atualize, .insira y .remova hacen explícito que el resultado es una lista nueva.

12 · Abstracción

Programación funcional

Una función puede recibir otra función como argumento o devolverla como resultado. Las expresiones lambda, escritas con =>, describen operaciones breves sin declarar una función con nombre.

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 conserva los elementos que cumplen una condición.
• mapeie transforma cada elemento y devuelve una lista.
• injete recorre la colección y combina sus elementos con un acumulador inicial.

Estas operaciones no cambian la lista de origen. Los tipos de parámetros y resultados permiten comprobar que la transformación corresponde a los datos.

Comprensión de listas

Una comprensión combina una o más secuencias generadoras con una expresión para producir una lista nueva. Cada generador puede depender de los valores anteriores.

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

Currying

Una función con currying recibe sus argumentos por etapas: cada llamada parcial devuelve otra función. Así se puede guardar una función ya configurada para reutilizarla.

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

Recursión de cola

En la recursión de cola, la llamada recursiva es la última operación del caso. La documentación de Potigol presenta esta forma con optimización, adecuada para recorridos recursivos que conservan un 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 · Decisiones por estructura

Emparejamiento de patrones

escolha puede comparar un valor con casos o examinar la estructura de una lista. El patrón [] representa una lista vacía; cabeça :: cauda separa el primer elemento del resto. El patrón _ acepta cualquier valor y una condición adicional puede limitar un 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 => "cero"
  caso _ => "positivo"
fim

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

Los casos se evalúan en orden; coloca los patrones específicos antes de uno amplio como _. En funciones recursivas, el caso vacío ofrece la condición de parada.

14 · Biblioteca de juegos

Jerimum: juegos con Potigol

Jerimum es una biblioteca de juegos para Potigol. El repositorio oficial reúne ejemplos y módulos para abrir una ventana, dibujar imágenes y texto, consultar teclado y ratón, medir tiempo y reproducir audio. Añade recursos para juegos y se mantiene separado de la sintaxis central de Potigol.

Inicio y ciclo del juego

Un programa comienza con use "jerimum" y define atualize() para actualizar el estado y desenhe() para registrar lo que se dibuja. jogo.iniciar recibe título, ancho, alto, ambas funciones y una tasa de cuadros opcional, cuyo valor predeterminado es 60.

use "jerimum"

atualize()
  # Atualize o estado do jogo
fim

desenhe()
  # Registre imagens e textos do quadro
fim

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

jogo expone largura, altura, título y fps. La ventana se crea mediante Swing/AWT y tiene dimensiones fijas. Jogo.distância, Jogo.projeção_X y Jogo.projeção_Y ayudan con cálculos de movimiento; sus ángulos se expresan en grados.

Dibujo, capas e imágenes

Imagem("archivo.png") carga una imagen. desenhe(x, y, z) la sitúa en coordenadas y una capa entera. Las capas con número mayor se dibujan delante. También existen dibujo centrado, rotación, escala y recorte de hojas de sprites mediante 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) selecciona imágenes de una secuencia según el tiempo transcurrido.

Teclado, ratón y tiempo

Teclado ofrece valores lógicos como TECLA_PARA_DIREITA, TECLA_ENTER y TECLA_A a TECLA_Z. Mouse.x y Mouse.y indican la posición; Mouse.BOTAO_ESQUERDO y Mouse.BOTAO_DIREITO consultan los botones. Relógio.milisegundos cuenta el tiempo desde la inicialización.

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, colores, audio y archivos

Fonte(tamanho) crea una fuente. Sus métodos de dibujo reciben texto, coordenadas y capa; aceptan color. Cor(vermelho, verde, azul) crea un color RGB y también hay constantes como Cor.BRANCO, Cor.PRETO y Cor.VERDE.

Som("efeito.wav") reproduce efectos con toque(). Musica("faixa.wav") ofrece toque, pause, continue, pare y tocando; comienza en bucle por defecto. Arquivo.leia("dados.txt") devuelve las líneas del archivo en una lista.

Ejemplo: mover una imagen

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)

Los detalles de cada método están en la documentación y el código fuente del repositorio Jerimum. La biblioteca usa recursos Java para ventanas, dibujo y audio; sus ejemplos se refieren a programas Potigol de escritorio.

15 · Ejemplo integrado

Calcular el promedio

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 · Lectura adicional

Referencias

• Documentación oficial de Potigol, con temas de sintaxis, estructuras, funciones, tipos, listas y tuplas.
• Referencias oficiales de números, textos, matemáticas y funciones.
• Referencias oficiales de listas, tuplas y programación funcional, con comprensión de listas, expresiones lambda, currying, recursión de cola y emparejamiento de patrones.
• Repositorio oficial de Potigol y gramática publicada.
• Repositorio oficial de Jerimum, con documentación y ejemplos.
• Referencias de Jogo, Imagem, Teclado, Mouse, Fonte y Cor; el código fuente también describe audio, animación y lectura de archivos.