Intermediate ru

Продвинутый — потоки, классы, файлы и проекты

English | 中文 | Русский

Реальное использование: потоки и реализации, классы и объекты, система предположений need, массивы, файловый ввод-вывод, нити и сборка реальных проектов.

Потоки: сигнатура и реализация

Сигнатурный поток объявляет, что умеет делать поток; реализация (fork) воплощает это. Вызовы идут через сигнатуру, реализации подключаются.

// Signature: what the stream offers
Stream Greeter {
    void greet(name string);
}

// Fork: how it works
Greeter FriendlyGreeter {
    void greet(name string) {
        CIO::println("hello,", name);
    }
}

Вызов:

Greeter::greet("TAK");
// hello, TAK

Вызов по имени сигнатурного потока переходит к его потоку-реализации.

Потоки с полями

Stream Counter {
    int count;
    void bump();
}
Counter C {
    void bump() { this::count = count + 1; }
}

this::count обращается к собственному полю потока; count разрешается по цепочке областей видимости. Голые вызовы (bump()) работают внутри потока.

Классы и объекты

Класс — это поток, который можно инстанцировать:

Class Hero {
    int hp;
    void __init__() {
        this::hp = 100;
    }
    void takeDamage(d int) {
        this::hp = hp - d;
    }
}

Main {
    void exec() {
        Hero h = new Hero();          // __init__ runs
        h::takeDamage(30);
        CIO::println("hp =", h.hp);   // 70
    }
}

• new ClassName() создаёт объект; __init__ — конструктор.
• obj::method(...) вызывает методы, obj.field читает поля.
• Obj::set("name", v) / Obj::get("name") — динамический доступ к атрибутам.
• Смытый атрибут отказывает в доступе: «свойство X было смыто».

Система предположений need

need объявляет зависимость; поставщики собираются автоматически:

need value GREETING;          // a constant
need function greet;          // a method named greet
need Stream Greeter;          // a stream
need Class Hero;              // a class

// provider file (any included file):
const string GREETING = "Hello from utils/";

bio build рекурсивно включает каждого поставщика, достижимого из точки входа main, — need без поставщика — это ошибка.

Массивы

Массивы BioLang растут автоматически:

int[] squares = new int[4];
for (int i = 0; i < 4; i = i + 1;) { squares[i] = i * i; }
CIO::println(squares);                    // [ 0 1 4 9 ]

ALL a = new Array(3);
a::set(0, 10);
a::push(40);                              // grows
CIO::println(a::join("-").res);           // join into a string

Классы Array и Vector написаны на самом BioLang; Arrays::count(), Arrays::forget(v) управляют живыми экземплярами.

Несколько возвращаемых значений

void triple(a int) { res a, a * 2, a * 3; }   // respond with several values

ALL t = triple(10);       // t.res is an array [10, 20, 30]
CIO::println(get t);

res a, b, c; отвечает сразу несколькими значениями; они приходят как сырой массив.

Файловый ввод-вывод

FIO — файловый поток. Откройте файл, затем читайте/пишите через основные методы ввода-вывода:

// Writing:
FIO::open("notes.txt", "w");
FIO::println("line one");
FIO::close();

// Reading (text):
FIO::open("notes.txt");
string line = FIO::getln();
CIO::println("read:", line);
FIO::close();

// Reading (bytes):
FIO::open("data.bin");
int byte = FIO::read();           // 0-255, -1 at EOF

Текстовые методы: print / println / get / getln. Байтовые методы: write / read. Также FIO::writeFile(path, content) и FIO::readFile(path) для операций с целыми файлами.

SIO — строковый буфер

SIO хранит строку в памяти, с которой работают методы ввода-вывода, — удобно для построения текста:

SIO::println("Hello");
SIO::print("World");
CIO::println(SIO::content());     // Hello\nWorld
CIO::println(SIO::buf());         // whole buffer incl. consumed bytes
SIO::clear();

Инструменты: format, length, upper, lower, trim, contains, substring, replace.

Нити (кооперативные)

Calc Worker {
    void factorial(n int) {
        int r = 1;
        for (int i = 2; i <= n; i = i + 1;) r = r * i;
        res r;
    }
}

Main {
    void exec() {
        ALL t = Threads::spawn("factorial", 10);
        ALL result = Threads::join(t);
        CIO::println("10! =", get result);    // 3628800
    }
}

• Threads::spawn(name, args...) запускает голый метод на новой нити.
• Threads::join(t) ожидает завершения и забирает результат.
• Threads::active(), Threads::self(), Threads::yield().
• Нити кооперативные — без вытеснения; нить должна вызвать yield или завершиться, чтобы работали другие.

Taskm — диспетчер задач

Циклическое планирование задач (round-robin):

Taskm::interval(1);                  // rotate roughly every 1 ms
ALL t1 = Taskm::add("jobA", 5);
Taskm::run();                        // run until all tasks finish
CIO::println(get Threads::join(t1));

Сборка проекта

Проект = package.toml + src/ + utils/ + .biolang/deps/:

bio init myapp          # skeleton
# edit src/main.bio, add utils/, declare dependencies
bio build myapp -s      # standalone executable
bio run myapp           # or run interpreted

package.toml:

name = "myapp"
version = "0.1.0"
[dependencies]
libfoo = { version = "1.0.0", repo = "https://github.com/user/libfoo" }

Разрешение зависимостей: собственный repo зависимости → файл BIOLANG_CONFIG → ~/.biolang/config.toml.

Компиляция и упаковка

bio shell build hello.bio          # → bin/hello (standalone executable)
bio build myapp -s                 # project → standalone
bio build myapp -m                 # project → bin/myapp.img (app + platform CLI + libs)
bio build myapp -m dist.zip        # → .zip package
bio pack hello.img --entry hello bin/hello
bio run hello.img                  # run a package

Форматы .img / .zip описаны в Packaging.

Что дальше

• Эксперт — умные ссылки, бинарные библиотеки, память, кроссплатформенность.
• Введение — если вы пропустили основы.