Wie mache ich einen grundlegenden import - /einschließen, der eine Funktion aus einem anderen Modul in Rust 2015?

Ich kann nicht herausfinden, wie zu zählen (oder importieren, injizieren, oder ein anderes Wort) eine Funktion aus einer Datei (Modul) in ein anderes.

Starte ich ein neues Projekt mit

$ cd ~/projects
$ cargo new proj --bin
$ cd proj
$ tree
.
|
-- Cargo.toml
-- src
   |
   -- main.rs

Ich ändern main.rs und erstellen Sie eine neue Datei a.rs (innerhalb der src dir) mit dem folgenden code:

main.rs

fn main() {
    println!("{}", a::foo());
}

ein.rs

pub fn foo() -> i32 { 42 }

Führe ich das Projekt mit cargo run und bekomme die Fehlermeldung:

error[E0433]: failed to resolve: use of undeclared type or module `a`
 --> src/main.rs:2:20
  |
2 |     println!("{}", a::foo());
  |                    ^ use of undeclared type or module `a`

Es scheint, dass ich brauche, um den import der a irgendwie. Ich versuchte, fügen Sie Folgendes als erste Zeile zum main.rs

  • use a; 

    error[E0432]: unresolved import `a`
 --> src/main.rs:1:5
  |
1 | use a;
  |     ^ no `a` in the root

  • use a::*;

    error[E0432]: unresolved import `a`
 --> src/main.rs:1:5
  |
1 | use a::*;
  |     ^ maybe a missing `extern crate a;`?

error[E0433]: failed to resolve: use of undeclared type or module `a`
 --> src/main.rs:4:20
  |
4 |     println!("{}", a::foo());
  |                    ^ use of undeclared type or module `a`

  • use a::foo;

    error[E0432]: unresolved import `a`
 --> src/main.rs:1:5
  |
1 | use a::foo;
  |     ^ maybe a missing `extern crate a;`?

error[E0433]: failed to resolve: use of undeclared type or module `a`
 --> src/main.rs:4:20
  |
4 |     println!("{}", a::foo());
  |                    ^ use of undeclared type or module `a`

  • extern crate a; use a::foo; 

    error[E0463]: can't find crate for `a`
 --> src/main.rs:1:1
  |
1 | extern crate a;
  | ^^^^^^^^^^^^^^^ can't find crate

  • extern crate proj; use proj::a::foo; 

    error[E0463]: can't find crate for `proj`
 --> src/main.rs:1:1
  |
1 | extern crate proj;
  | ^^^^^^^^^^^^^^^^^^ can't find crate

Habe ich gelesen, die Anleitung aber immer noch nicht herausfinden, wie die Importe.

InformationsquelleAutor vil | 2014-10-06
  1. 38

    In einem mainish module (main).rs, lib.rs, oder subdir/mod.rs), die Sie schreiben müssen mod a; für alle anderen Module, die Sie verwenden möchten, in das gesamte Projekt (oder in den Ordner).

    In allen anderen Modulen, die Sie schreiben müssen use a; oder use a::foo;

    Du bist bei weitem nicht der einzige Mensch zu sein, verwirrt von diesem, und es ist durchaus möglich, besser zu machen, aber irgendwelche änderungen an der Modul-system bekommen werden abgelehnt als "zu verwirrend".

    Edit: diese Antwort wurde geschrieben für die "Rust 2015" Sprache standard. Änderungen wurden für die "Rost-2018" - standard finden Sie unter in diesem blog-post und die edition guide

    • Also, wenn extern crate notwendig? Ich dachte, dass jedes Rost-Datei eine separate Kiste (unit of-compilation).
    • Ihre wichtigsten.rs oder lib.rs und alle Dateien rekursiv revers über mod Anweisungen kompiliert werden, wie eine Kiste. Dies ist die Einheit für die Zusammenstellung.
    • but any changes to the module system will get rejected as "too confusing" Der vorhandenen Modul-system ist "zu unübersichtlich".
    • Ich finde diese Antwort ist verwirrend, schlagen Sie vor zu stellen mod a; im Haupt-und in der Sekundär-Dateien use a; - sollte es nicht andersherum sein - mein main ist mit Sachen von anderen Dateien..
    • Vielen Dank, die Lösung " - mod ein; in main.rs, und verwenden Sie ein; in ein.rs" für mich funktioniert.
    • Ich habe Stunde versuchen, um dies herauszufinden. Keine andere Sprache hat eine import-system mit so vielen verschiedenen Stichwörtern, Bedeutungen, Nuancen, und nicht-offensichtliche Merkmale.

    InformationsquelleAutor o11c
  2. 14

    In Rust, es gibt einige Stichworte zum Umgang mit Modulen:

    extern crate

    extern crate füllt die Lücke zwischen Ladung und Rost. Wir schreiben von code in einer .rs-Datei, diese Datei kompiliert werden kann, mit rustc. Ladung verwalten externe Abhängigkeiten und rufen rustc. Die extern crate ... Zeile weist den compiler an, suchen Sie für dieses namespace, so ist es eindeutig.

    Anmerkung der Redaktion — extern crate ist nicht erforderlich, in vielen Fällen, wenn Sie mit dem Rost 2018 edition.

    mod

    mod hat zwei Verwendungen:

    • wenn verwendet mit geschweiften Klammern, es wird ein Modul (namespace).
    • wenn verwendet, mit nur ein name, es wird sich für Sie das Modul in das lokale Dateisystem.

    Module können sein:

    • Dateien mit der Erweiterung .rs
    • Ordner mit einer Datei namens mod.rs

    use

    use Import eines namespace. Wir sind verpflichtet, zu verkünden, was werden wir nutzen, bevor es zu benutzen. Die Verwendung der Klausel ist ziemlich streng, wenn wir sagen use module1::moduleA; kein anderes Modul aus module1 erhältlich sein wird, aber moduleA. Ein Sternchen (*) kann verwendet werden um alles in einem Modul: use module1::*;. Die Sätze können auch verwendet werden: use module1::{moduleA, moduleB};

    Beispiel:

    | main.rs
|- module1
      |- mod.rs
      |- moduleA.rs
      |- moduleB.rs

    mod.rs enthält:

    pub mod moduleA; //declare a child module
pub mod moduleB; //declare a child module

    main.rs enthält:

    /// ======
//use what Cargo downloaded
extern crate that_one_thing_i_need;

/// ======

mod module1; //declare a child module

//some local stuff I want to scope
mod local {
    pub fn my_function() {}
}

//  ======

//make the symbols locally available:
use module1::moduleA::*;
use module1::moduleB::{functionX, moduleY, typeZ};

//we still need to announce what stuff from the external crate
//we want to use:
//We can do local aliases that will be valid in this one file.
use that_one_thing_i_need::fancy_stuff as fs;

/// ======

fn main() {
    //we can use anything here from the namespaces we are using:
    //     moduleA
    //     functionX
    //     moduleY
    //     typeZ
    //     fs

    //We can access stuff by navigating from the outermost visible
    //module name
    local::my_function();
}

    Symbole sind nur nutzbar, die von innerhalb des Moduls. Wenn Sie möchten, überqueren diese Barriere (auch auf ein lokal deklariertes Modul) benötigen wir, um Sie der öffentlichkeit mit dem Stichwort pub.

    • Wie schreiben Sie, wenn moduleA braucht Sachen aus moduleB ? Und vielleicht Umgekehrt?
    • Ich kämpfte mit genau diesem Szenario (ein Modul importieren etwas von seiner 'Geschwister' oder direkt 'parent') mehrere Male in der Vergangenheit und noch tun. Die kurze Antwort ist, um use crate::parent oder use crate::sibling.
    InformationsquelleAutor Luis Ayuso
Schreibe einen Kommentar