❧ O que é o Slang ❧

Guia da Linguagem Slang1.1

Slang é uma linguagem de programação didática projetada para o ensino de compiladores. Ela possui uma sintaxe familiar, combinando elementos de C, Python e Rust, com suporte a tipos estáticos, funções e estruturas de controle fundamentais.

Estrutura Léxica (Tokens)1.1.1

A tabela abaixo descreve os tokens da linguagem e as expressões regulares (Regex) utilizadas para sua identificação no Prism.js.

Tipos de Dados1.1.2

Slang suporta os seguintes tipos básicos:

Variáveis e Declaração1.1.3

As variáveis são declaradas com a sintaxe nome: tipo = valor.

x: int = 10
pi: float = 3.1415
nome: string = "Slang"
ativo: bool = true
letra: char = 'A'

Operadores1.1.4

Aritméticos1.1.4.1

Relacionais1.1.4.2

Lógicos1.1.4.3

Slang permite tanto a notação simbólica quanto a textual para operações lógicas:

if (ativo and x > 0) || !validado {
    // Código aqui
}

Estruturas de Controle1.1.5

Condicionais (if / else)1.1.5.1

if x > 5 {
    print("Maior que 5")
} else {
    print("Menor ou igual a 5")
}

Laços de Repetição (loop)1.1.5.2

O loop é a única estrutura de repetição da linguagem. Ele aceita uma condição opcional e executa o bloco enquanto ela for verdadeira. Sem condição, executa indefinidamente.

loop x < 10 {
    print(x)
    x = x + 1
}

Controle de Fluxo do Laço1.1.5.3

break — Interromper o laço1.1.5.3.1

O break encerra imediatamente a execução do laço mais interno.

loop x < 10 {
    if x == 5 {
        break
    }
    x = x + 1
}
// Executa até x == 5 e para

continue — Pular para a próxima iteração1.1.5.3.2

O continue pula o restante do corpo do laço e vai direto para a próxima verificação da condição.

loop x < 10 {
    x = x + 1
    if x % 2 == 0 {
        continue
    }
    print(x) // Imprime apenas os ímpares
}

return — Encerrar uma função1.1.5.4

O return finaliza a execução da função atual e, opcionalmente, retorna um valor.

fn absoluto(n: int) -> int {
    if n < 0 {
        return n * -1
    }
    return n
}

Funções1.1.6

As funções são definidas com a palavra-chave fn, seguida pelo nome, parâmetros e o tipo de retorno indicado por ->.

fn somar(a: int, b: int) -> int {
    return a + b
}

fn principal(args: void) -> void {
    resultado: int = somar(5, 3)
    print(resultado)
}

• Funções que não retornam valor usam -> void.
• O tipo de cada parâmetro é obrigatório: nome: tipo.

Comentários1.1.7

// Comentário de linha — ignorado até o fim da linha

/* Comentário de bloco
   pode ocupar várias linhas */

Exemplo Completo1.1.8

Abaixo, um exemplo que demonstra a maioria dos recursos da linguagem:

/* 
   Cálculo de Fatorial em Slang
*/

fn fatorial(n: int) -> int {
    if n <= 1 {
        return 1
    }
    return n * fatorial(n - 1)
}

fn contar_impares(limite: int) -> void {
    x: int = 1
    loop x <= limite {
        if x % 2 == 0 {
            x = x + 1
            continue        // Pula números pares
        }
        print(x)
        if x == 7 {
            break           // Para ao chegar no 7
        }
        x = x + 1
    }
}

fn main(args: void) -> void {
    x: int = 5
    resultado: string = "O fatorial é: "

    if x >= 0 and x < 13 {
        print(resultado)
        print(fatorial(x))
    } else {
        print("Erro: Entrada inválida")
    }

    contar_impares(10)
}