Pakete & Crates

Was ist eine Crate?

Eine Crate ist die kleinste Menge an Code, die der Rust-Compiler auf einmal betrachtet. Es gibt zwei Arten:

• Binary-Crate: kompiliert zu einer ausführbaren Datei (ein main.rs). Jede Binary-Crate hat eine main-Funktion.
• Library-Crate: kompiliert zu einer Bibliothek (ein lib.rs), die andere Programme importieren können. Sie hat keine main-Funktion.

Was ist ein Paket?

Ein Paket (package) ist ein Bundle aus einer oder mehreren Crates plus einer Cargo.toml-Datei. Ein Paket kann enthalten:

• eine Binary-Crate oder eine Library-Crate, oder beides
• mehrere Binary-Crates (in src/bin/)

Standardmäßig interpretiert Cargo src/main.rs als Binary- und src/lib.rs als Library-Crate. src/main.rs ist die Crate-Root — das Modul, in dem alles beginnt.

Module: Kontrolle über Umfang & Sichtbarkeit

Mit mod strukturieren

Module erlauben es, Code in benannte Gruppen zu gliedern und die Privatsphäre zu steuern. Standardmäßig ist alles in einem Modul privat — für Außenstehende unsichtbar:

mod back_of_house {
    fn cook_order() {}
}

fn main() {
    // Fehler: cook_order ist privat!
    // back_of_house::cook_order();
}

Um auf Inhalte eines Moduls zuzugreifen, nutzt man Pfade (paths):

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

fn main() {
    // Absoluter Pfad (mit crate::)
    crate::front_of_house::hosting::add_to_waitlist();
    // Relativer Pfad (ohne crate::)
    front_of_house::hosting::add_to_waitlist();
}

pub macht ein Item öffentlich. Wichtig: pub auf einem Modul macht das Modul sichtbar, aber nicht automatisch dessen Inhalte — jedes Item braucht sein eigenes pub.

use: Pfade in den Scope holen

use verkürzt Pfade

Statt jedes Mal den vollen Pfad zu schreiben, holst du ein Item mit use in den Scope:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

fn main() {
    hosting::add_to_waitlist();
}

Danach schreibst du hosting::add_to_waitlist() statt des vollen Pfads.

Konventionen

• Funktionen: use des Elternmoduls (nicht der Funktion), damit klar bleibt, woher sie kommt — hosting::add_to_waitlist().
• Structs/Enums: use des vollen Pfads — use std::collections::HashMap; dann HashMap::new().
• Aliase bei Namenskollision: use std::io::Result as IoResult;.

Mehrere Dateien: Module aufteilen

Module in separate Dateien auslagern

Wächst dein Modul, legst du es in eine eigene Datei. Aus

// lib.rs
mod front_of_house {
    pub mod hosting { /* ... */ }
}

wird:

// lib.rs
mod front_of_house;
// Inhalt liegt jetzt in src/front_of_house.rs

Rust sucht den Inhalt von front_of_house dann in src/front_of_house.rs.

Modul-Bäume mit Verzeichnissen

Hat ein Modul Untermmodule, nutzt du ein Verzeichnis:

// lib.rs
mod front_of_house;
// src/front_of_house/mod.rs
pub mod hosting;
// src/front_of_house/hosting.rs

mod front_of_house; sucht zuerst src/front_of_house.rs, dann src/front_of_house/mod.rs. (Die mod.rs-Variante ist älter; heute bevorzugt man front_of_house.rs neben einem front_of_house/-Ordner.)

Sichtbarkeit: pub, pub(crate) & Freunde

Feinstufige Sichtbarkeit

Neben pub (für alle sichtbar) und privat (nur im Modul) gibt es Abstufungen:

• pub(crate) — sichtbar innerhalb der gesamten Crate, aber nicht von außen
• pub(super) — sichtbar im Elternmodul
• pub(in path) — sichtbar innerhalb eines bestimmten Pfads

mod geheim {
    pub(crate) fn intern() {}   // überall in der Crate nutzbar
    pub(super) fn im_eltern() {} // nur im Elternmodul
    fn privat() {}               // nur hier
}

Sichtbarkeit nach außen

Für eine Library-Crate gilt: pub macht ein Item zur öffentlichen API für andere Crates. Alles, was du als pub markierst, ist ein Versprechen an deine Nutzer — Änderungen daran brechen deren Code. Wähle die öffentliche API bewusst.

Re-Exporte & Modul-Baum-Pflege

pub use für Re-Exporte

Ein Re-Export stellt ein Item an einem anderen Ort bereit:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// Re-Export: macht add_to_waitlist direkt hier verfügbar
pub use crate::front_of_house::hosting::add_to_waitlist;

fn main() {
    add_to_waitlist();
}

Nutzer schreiben dann add_to_waitlist() statt front_of_house::hosting::.... Re-Exporte sind ideal, um eine übersichtliche öffentliche API zu bauen, während die interne Struktur frei bleibt.

Deine API gestalten

• Exportiere das, was Nutzer brauchen, unter einem klaren Namen
• Halte interne Module privat und strukturiere frei um
• Re-Exporte trennen interne Organisation von öffentlicher Oberfläche

Übung: Ein Restaurant-Backend strukturieren

Projekt: Module wie in einem echten Projekt

Du strukturierst ein kleines Programm nach den Regeln dieses Moduls:

1. Definiere ein Modul kueche mit einem öffentlichen Untermodul bestellung.
2. Lege im Untermodul eine Funktion bestellen(gericht: &str) an, die den Gerichtsnamen ausgibt.
3. Hole die Funktion mit use in den Scope und rufe sie in main auf.
4. Markiere eine Hilfsfunktion als pub(crate) und eine andere als privat — und prüfe, dass die private von außen nicht erreichbar ist.
5. Überlege: Welche Items wären Teil deiner öffentlichen API, wenn das eine Library-Crate wäre?

Das verbindet mod, pub, Pfade, use und Sichtbarkeit zu einem Ganzen.

Übung: Restaurant-Backend strukturieren