Pakiet Rust z biblioteką i binarnym?

Możesz także po prostu umieścić binarne źródła w src/bin, a resztę swoich źródeł w src. Przykład można zobaczyć w mój projekt. Nie musisz w ogóle modyfikować swojego Cargo.toml, a każdy plik źródłowy zostanie skompilowany do pliku binarnego o tej samej nazwie.

Konfiguracja drugiej odpowiedzi zostaje zastąpiona przez:

$ tree
.
├── Cargo.toml
└── src
    ├── bin
    │   └── mybin.rs
    └── lib.rs

Ładunek.toml

[package]
name = "example"
version = "0.0.1"
authors = ["An Devloper <[email protected]>"]

Src / lib. rs

use std::error::Error;

pub fn really_complicated_code(a: u8, b: u8) -> Result<u8, Box<Error>> {
    Ok(a + b)
}

Src / bin / mybin. RS

extern crate example;

fn main() {
    println!("I'm using the library: {:?}", example::really_complicated_code(1, 2));
}

I wykonać it:

$ cargo run --bin mybin
I'm using the library: Ok(3)

Dodatkowo, możesz po prostu utworzyć src/main.rs, który będzie używany jako plik wykonywalny defacto. Niestety, jest to sprzeczne z poleceniem cargo doc:

Nie można udokumentować pakietu, w którym biblioteka i plik binarny mają tę samą nazwę. Rozważ zmianę nazwy jednego lub oznaczenie celu jako doc = false

Możesz umieścić lib.rs i main.rs w folderze sources razem. nie ma konfliktu i ładunek zbuduje obie rzeczy.

Aby rozwiązać konflikt dokumentów Dodaj do swojego Cargo.toml:

[[bin]]
name = "main"
doc = false

Alternatywnym rozwiązaniem jest nie próbować pakować obu rzeczy w jeden pakiet. W przypadku nieco większych projektów z przyjaznym programem wykonywalnym bardzo miło jest używać workspace

Tworzymy projekt binarny, który zawiera wewnątrz niego bibliotekę:

the-binary
├── Cargo.lock
├── Cargo.toml
├── mylibrary
│   ├── Cargo.toml
│   └── src
│       └── lib.rs
└── src
    └── main.rs

Ładunek.toml

Używa klucza [workspace] i zależy od biblioteka:

[package]
name = "the-binary"
version = "0.1.0"
authors = ["An Devloper <[email protected]>"]

[workspace]

[dependencies]
mylibrary = { path = "mylibrary" }

Src / main. rs

extern crate mylibrary;

fn main() {
    println!("I'm using the library: {:?}", mylibrary::really_complicated_code(1, 2));
}

Mylibrary / src / lib.rs

use std::error::Error;

pub fn really_complicated_code(a: u8, b: u8) -> Result<u8, Box<Error>> {
    Ok(a + b)
}

I wykonaj:

$ cargo run
   Compiling mylibrary v0.1.0 (file:///private/tmp/the-binary/mylibrary)
   Compiling the-binary v0.1.0 (file:///private/tmp/the-binary)
    Finished dev [unoptimized + debuginfo] target(s) in 0.73 secs
     Running `target/debug/the-binary`
I'm using the library: Ok(3)

Istnieją dwie duże korzyści dla tego programu:

1. Binarny może teraz używać zależności, które tylko do niego odnoszą się. Na przykład możesz dołączyć wiele skrzyń, aby poprawić wygodę użytkownika, takich jak parsery wiersza poleceń lub formatowanie terminala. Żaden z nich nie" zainfekuje " biblioteki.

2. Przestrzeń robocza zapobiega redundantnym kompilacjom każdego komponentu. Jeśli uruchomimy cargo build zarówno w katalogu mylibrary, jak i the-binary, biblioteka nie będzie budowana za każdym razem - będzie współdzielona między obydwoma projektami.