Projeto multi-arquivo

Quando um projeto cresce, o código se divide em vários arquivos. Em Zolo, cada arquivo é um módulo: o arquivo de entrada declara os módulos com mod e importa o que precisa com use. O compilador localiza cada arquivo pelo nome, no mesmo diretório de quem declara o mod.

O exemplo a seguir mostra um programa com três arquivos: main.zolo (ponto de entrada), greeter.zolo (módulo de saudação) e helpers.zolo (utilitários numéricos). Como os arquivos dependem uns dos outros, eles precisam ser executados juntos — não há como rodá-los isoladamente no playground do browser.

helpers.zolo — define funções numéricas públicas e uma constante privada:

Módulo de suporte: add, double e circle_area são públicos; PI é privado ao módulo (sem pub).

helpers.zolo

Playground

// Module: helpers — numeric utilities.

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

pub fn double(x: int) -> int {
  return x * 2
}

const PI: float = 3.14159

pub fn circle_area(r: float) -> float {
  return PI * r * r
}

Requer a CLI/host do Zolo — abra no playground ou rode localmente.

greeter.zolo — expõe hello e farewell; a função auxiliar build_prefix permanece privada:

build_prefix não tem pub — é detalhe de implementação invisível para main.zolo.

greeter.zolo

Playground

// Module: greeter
// Anything `pub` is exported; the rest is private to the module.

pub fn hello(name: str) {
  let prefix = build_prefix()
  print("{prefix}, {name}!")
}

pub fn farewell(name: str) {
  print("Bye, {name}.")
}

// Private — called only from inside the module. It is not exposed
// in the `use greeter::...` over in main.
fn build_prefix() -> str {
  return "Hello"
}

Requer a CLI/host do Zolo — abra no playground ou rode localmente.

main.zolo — ponto de entrada que orquestra os dois módulos. O self na lista de use helpers traz o namespace helpers para o escopo ao mesmo tempo que os nomes individuais:

use helpers::{self, add, double, circle_area} permite tanto add(2, 3) (direto) quanto helpers.add(10, 20) (qualificado via namespace). Para executar: zolo run main.zolo dentro da pasta multi-file/.

main.zolo

Playground

// Feature: multi-file program with `mod` + `use`
// Structure:
//   main.zolo      <- entry point
//   greeter.zolo   <- `greeter` module
//   helpers.zolo   <- `helpers` module
//
// To run (from this folder):
//   zolo run main.zolo

// Declares that we will use the `greeter.zolo` and `helpers.zolo`
// files as modules. `mod` resolves each one by reading the file
// from the same directory.
mod greeter
mod helpers

// Imports specific names via `use`. The `self` entry in the list brings
// the module table itself into scope alongside the destructured items,
// so both `helpers.add(...)` and the bare `add(...)` work.
use greeter::{hello, farewell}
use helpers::{self, add, double, circle_area}

fn main() {
  hello("zolo")

  // expected: Hello, zolo!

  let sum = add(2, 3)
  print("2 + 3 = {sum}")

  // expected: 2 + 3 = 5

  // `helpers` is bound thanks to the `self` entry in the use list.
  print("helpers.add(10, 20) = {helpers.add(10, 20)}")

  // expected: helpers.add(10, 20) = 30

  print("double of 7 = {double(7)}")

  // expected: double of 7 = 14

  print("area(r=2) = {circle_area(2.0)}")

  // expected: area(r=2) = 12.56636

  farewell("zolo")
  // expected: Bye, zolo.
}

Requer a CLI/host do Zolo — abra no playground ou rode localmente.

Encontre seu caminho pela Zolo

Comece por aqui