Beginner pt

English | 中文 | Русский | Español | Português | 繁體中文 | Deutsch

Iniciante — primeiros passos com BioLang

Esta página ensina os conceitos centrais e o fluxo de controle. Você só precisa de um binário bio compilado e de um editor de texto.

O que é BioLang?

BioLang é uma linguagem orientada a fluxos. Em vez de "tudo é um objeto", aqui tudo é um fluxo — um fluxo de requisições e respostas. Cada operação que você executa é uma requisição que pode ser recusada. Isso torna o tratamento de erros uma parte de primeira classe da linguagem, não uma reflexão tardia.

Executando seu primeiro programa

Compile o interpretador:

make
# → bin/bio

Crie o hello.bio:

program main;

Main {
    void exec() {
        CIO::println("Hello, BioLang!");
    }
}

Execute-o:

bin/bio hello.bio
# Hello, BioLang!

Todo programa tem o mesmo esqueleto:

• program main; — declara que este arquivo é um programa principal (tem um ponto de entrada).
• Main { ... } — o fluxo do programa principal.
• void exec() { ... } — o método executado quando o programa inicia.

Tipos base e variáveis

Cinco tipos base:

Tipo	Significado	Exemplo
int	inteiro	42, -7
float	número de precisão simples	3.14
double	número de precisão dupla	3.14159265358979
string	texto	"hello"
char	caractere único	'x'

Declarando variáveis:

int age = 30;
string name = "BioLang";
double pi = 3.14159;
char grade = 'A';

Um const é uma constante de nível de programa somente leitura:

const int SPEED = 9;

O modelo de requisições: res, ref, get, cause

Cada chamada retorna um resultado de requisição que é um sucesso (res) ou uma recusa (ref). Este é o coração do BioLang.

ALL result = add(3, 4);     // a request result

Use get para extrair um sucesso e cause para obter o motivo da recusa:

CIO::println(get add(3, 4));        // 7
CIO::println(cause div(1, 0));      // refused: division by zero

• get x — o valor de uma requisição bem-sucedida.
• cause x — o motivo pelo qual uma requisição foi recusada.
• ALL x = ... — captura ambos; .res e .cause também funcionam.

Operadores

Aritmética: + - * / %

int a = 7 + 3;      // 10
int b = a * 2;      // 20
int c = b / 7;      // 2  (integer division)
int d = b % 7;      // 6  (remainder)

Incremento e decremento: i++, i--, além das formas compostas.

Fluxo de controle

if / else if / else

if (score >= 90) {
    CIO::println("A");
} else if (score >= 60) {
    CIO::println("B");
} else {
    CIO::println("C");
}

while

int i = 0;
while (i < 5) {
    CIO::println("i =", i);
    i = i + 1;
}

for

for (int i = 0; i < 5; i = i + 1;) {
    CIO::println("square", i, "=", i * i);
}

Observe o ; após a expressão de atualização — as três cláusulas são separadas por ponto e vírgula e o cabeçalho inteiro termina com ;.

break e continue

for (int i = 0; i < 10; i = i + 1;) {
    if (i == 3) continue;    // skip 3
    if (i == 7) break;       // stop at 7
    CIO::println(i);
}

Entrada e saída no console

CIO::print("Enter your name: ");     // no newline
string name = CIO::getln();          // read a line of text
CIO::println("Hello,", name);        // prints: Hello, <name>

CIO é o fluxo do console: print, println, get, getln, readInt, readNumber.

Juntando tudo

Um pequeno jogo de adivinhação (usa tudo o que foi visto acima):

program main;

Main {
    void exec() {
        const int SECRET = 7;
        CIO::println("Guess the number (1-10)!");

        for (int tries = 0; tries < 3; tries = tries + 1;) {
            int guess = CIO::readInt();
            if (guess == SECRET) {
                CIO::println("Correct! You win.");
                res;                  // success, end the program
            } else if (guess < SECRET) {
                CIO::println("Too low.");
            } else {
                CIO::println("Too high.");
            }
        }
        CIO::println("Out of tries. The answer was", SECRET);
    }
}

A seguir

• Intermediário — fluxos, classes, arquivos, projetos, threads.
• Avançado — referências inteligentes, bibliotecas binárias, empacotamento, compilações multiplataforma.
• Exemplos no repositório — 15 programas executáveis e bem comentados.