Bibliotecas de outras linguagens

Um único bloco deps declara bibliotecas de vários providers para o arquivo:

use plugin rust::{rust as rs}
use plugin native::{cpp}
use plugin jvm::{kotlin as kt}

deps {
    rs::serde_json = "1.0.145"
    cpp::fmt = { version = "11.0.2", default_features = true }
    kt::"com.google.guava:guava" = "33.4.0-jre"
}

Cada pacote qualificado começa com o nome importado da linguagem ou seu alias, seguido de ::. Use aspas nas chaves com pontuação. Strings curtas são versões exatas; as opções completas seguem as regras existentes do provider. A forma anterior extern provider deps continua disponível e pode coexistir com o bloco único.

Use serde_json, fmt e Guava em uma declaração, incluindo aliases dos providers. Prepare os pacotes com zolo install e depois execute o exemplo.

47-unified-dependencies.zolo

Playground

// Prepare once: zolo install examples/features/14-modules/47-unified-dependencies.zolo
// Requires Rust, C++/vcpkg and the JVM/Kotlin provider toolchains for preparation.
// parity-timeout-ms:300000
use plugin rust::{rust as rs}
use plugin native::{cpp}
use plugin jvm::{kotlin as kt}

deps {
    rs::serde_json = "1.0.145"
    cpp::fmt = { version = "11.0.2", default_features = true }
    kt::"com.google.guava:guava" = "33.4.0-jre"
}

extern rs fn answer() -> int {
    let value: serde_json::Value = serde_json::from_str(r#"{"answer":42}"#).unwrap();
    value["answer"].as_i64().unwrap()
}

extern cpp fn formatted(value: int) -> str {
    #include <fmt/format.h>
    return fmt::format("exact {}", value);
}

extern kt fn join(values: [str]) -> str {
    import com.google.common.base.Joiner
    return Joiner.on(", ").join(values.asIterable())
}

print(answer())
print(formatted(9007199254740993))
print(join(["Kotlin", "Maven", "Zolo"]))

// expected:
// 42
// exact 9007199254740993
// Kotlin, Maven, Zolo

Para várias bibliotecas do mesmo provider, coloque as chaves dentro de um grupo:

Playground

deps {
    rs {
        serde_json = "1.0.145"
    }
    cpp::fmt = { version = "11.0.2", default_features = true }
    kt {
        "com.google.guava:guava" = "33.4.0-jre"
    }
}

O grupo usa o provider importado ou seu alias. Grupos podem se repetir e coexistir com entradas qualificadas e os blocos extern provider deps. Versões, opções, política de instalação e lock seguem as mesmas regras. Os grupos têm apenas um nível; cada pacote herda o provider do seu grupo.

Misture grupos com uma entrada C++ qualificada e reutilize as mesmas dependências.

48-grouped-dependencies.zolo

Playground

// Prepare once: zolo install examples/features/14-modules/48-grouped-dependencies.zolo
// Requires Rust, C++/vcpkg and the JVM/Kotlin provider toolchains for preparation.
// parity-timeout-ms:300000
use plugin rust::{rust as rs}
use plugin native::{cpp}
use plugin jvm::{kotlin as kt}

deps {
    rs {
        serde_json = "1.0.145"
    }
    cpp::fmt = { version = "11.0.2", default_features = true }
    kt {
        "com.google.guava:guava" = "33.4.0-jre"
    }
}

extern rs fn answer() -> int {
    let value: serde_json::Value = serde_json::from_str(r#"{"answer":42}"#).unwrap();
    value["answer"].as_i64().unwrap()
}

extern cpp fn formatted(value: int) -> str {
    #include <fmt/format.h>
    return fmt::format("exact {}", value);
}

extern kt fn join(values: [str]) -> str {
    import com.google.common.base.Joiner
    return Joiner.on(", ").join(values.asIterable())
}

print(answer())
print(formatted(9007199254740993))
print(join(["Kotlin", "Maven", "Zolo"]))

// expected:
// 42
// exact 9007199254740993
// Kotlin, Maven, Zolo

As funções continuam usando os imports da própria linguagem. Aliases funcionam normalmente: javascript e typescript compartilham o ambiente Node; csharp usa .NET.

Use NumPy, date-fns e MathNet com versões exatas, sem instalar bibliotecas dentro das funções. O primeiro zolo run de um script independente prepara os pacotes antes de compilar e salva 36-extern-dependencies.zolo.lock ao lado dele.

36-extern-dependencies.zolo

Playground

// In the examples project: zolo install examples/features/14-modules/36-extern-dependencies.zolo
// Copied outside a project, the first run prepares packages and writes this script's lock.
// Subsequent runs reuse verified environments. Requires the provider runtimes.
// parity-timeout-ms:120000
use plugin python::{python}
use plugin node::{typescript as ts}
use plugin dotnet::{csharp}

extern python deps {
    numpy = "2.3.3"
}

extern ts deps {
    "date-fns" = "4.1.0"
}

extern csharp deps {
    "MathNet.Numerics" = "5.0.0"
}

extern python fn mean(values: [float]) -> float {
    import numpy as np
    return float(np.mean(values))
}

extern ts fn date_label(value: string) -> string {
    import { format, parseISO } from "date-fns";
    return format(parseISO(value), "yyyy-MM-dd");
}

extern csharp fn factorial(n: int) -> float {
    using MathNet.Numerics;
    return SpecialFunctions.Factorial(checked((int)n));
}

print(mean([10.0, 20.0, 30.0]))
print(date_label("2026-09-30"))
print(factorial(5))

// expected:
// 20
// 2026-09-30
// 120

Nos projetos, declare as bibliotecas no zolo.toml:

[packages]
schema = 2

[foreign]
install = "manual"

[foreign.python.dependencies]
numpy = "2.3.3"

[foreign.node.dependencies]
"date-fns" = "4.1.0"

[foreign.dotnet.dependencies]
"MathNet.Numerics" = "5.0.0"

Execute zolo install uma vez e depois zolo run. Todas as funções que usam esse provider recebem o mesmo ambiente isolado. O projeto guarda os pacotes Zolo e as dependências externas no mesmo zolo.lock. Declarações iguais no código e no manifesto se combinam; versões conflitantes apontam as duas origens.

Strings curtas sempre representam versões exatas. Para intervalos ou extras Python, use a forma completa, também disponível nos blocos de código. Para npm, o pin exige uma versão completa: 4.1.0; 4 e 4.1 exigem requirement:

Playground

extern python deps {
    numpy = { requirement = ">=2.2,<3" }
    httpx = { version = "0.28.1", extras = ["http2"] }
}

requirement usa as regras do gerenciador daquela linguagem. Intervalos entram no lock como versões resolvidas; execuções posteriores reaproveitam esse resultado.

zolo install analysis.zolo
zolo add python:[email protected]
zolo add node:[email protected]
zolo add dotnet:[email protected]
zolo run analysis.zolo --offline --frozen

Scripts independentes usam auto; projetos usam manual. Configure [foreign] install = "auto" ou passe --install=auto para preparar pacotes faltantes ao executar. --offline permite somente o cache local; --frozen exige um lock correspondente e impede alterações nele. As opções depois de -- pertencem ao seu programa.

O editor usa ambientes já preparados e oferece uma ação explícita para instalar. Abrir um arquivo não baixa pacotes nem executa seus imports. A primeira versão aceita wheels Python, pacotes npm sem scripts de instalação e os assets NuGet compatíveis com o framework e a plataforma selecionados, além de JARs Maven para Java. Os providers e seus runtimes precisam estar disponíveis separadamente. Veja Java com extern para coordenadas Maven, seleção da versão Java e a tabela global [foreign.jvm.dependencies].

Bibliotecas de outras linguagens

Encontre seu caminho pela Zolo

Comece por aqui