Ich versuche seit einem Monat, Rust zu lernen, und scheitere immer wieder an async/await. Jedes Mal, wenn ich versuche, eine async-Funktion zu schreiben, die eine andere async-Funktion aufruft, bekomme ich diese verwirrenden Lifetime-Fehler. Gibt es gute Tutorials oder Muster, die das endlich mal verständlich erklären, statt mir nur Compilerfehler um die Ohren zu hauen?
Die Lifetime-Fehler sind eigentlich nicht das eigentliche Problem - sie sind Symptome von etwas Einfacherem. Bevor du dich in den Borrow Checker verbisst, versuch das: Schreib deine async-Funktionen mit expliziten `Box<dyn Future<Output = YourType>>`-Rückgabetypen statt der `impl Future`-Syntax, zumindest während du lernst. Das zwingt dich, genau zu sehen, was erfasst wird, und macht den Compiler weniger kryptisch darüber, was eigentlich fehlschlägt. Sobald du eine funktionierende Version auf diese Weise hast, kannst du zurück zu `impl Future` refaktorieren und verstehen, *warum* der Compiler es jetzt akzeptiert, statt nur so lange herumzuprobieren, bis die Fehler weg sind.
Nutzt du `.await` an den Aufrufstellen, oder rufst du die async-Funktion auf, ohne sie zu awaiten? Die Lifetime-Fehler laufen oft darauf hinaus, dass der Compiler eine geliehene Referenz sieht, die kürzer lebt als die Future sie braucht - das hat nichts damit zu tun, dass async Magie ist, es ist einfach Rusts Borrow Checker, der seine Arbeit über await-Punkte hinweg macht. Das offizielle Async-Rust-Buch (auf der Rust-Website) hat einen Abschnitt, der genau das durchgeht, und es ist ehrlich gesagt verständlicher als die meisten Tutorials. Wenn du spezifischen Fehlermeldungen hinterherjagst, versuche ein kleines Beispiel zu isolieren, das fehlschlägt, und poste es auf r/rust oder dem Rust-Forum - die Leute dort sind geduldig dabei, das eigentliche Problem zu erklären, statt sich im Fehlerlärm zu verlaufen.
hör auf, gegen den borrow checker zu kämpfen, und denk stattdessen an async/await als die Erstellung einer state machine - jeder await-punkt ist im grunde eine pause, in der rust wissen muss, welche daten bis zur nächsten pause überleben. deshalb bekommst du lifetime-fehler. der compiler ist nicht stur, er ist einfach genuinely unsicher, ob deine geliehenen daten noch gültig sind, wenn die ausführung wieder aufgenommen wird.
das offizielle rust async book (rust-lang.org/what/wasm/book) ist eigentlich solide für das thema, aber mir hat mehr geholfen, tokios tutorial durchzulesen, weil es echte beispiele statt abstrakter theorie nutzt. Jon Gjengsets video-serie auf youtube über async rust verstehen viele leute - er führt dich schritt für schritt durch das mentale modell durch, statt dir einfach syntax um die ohren zu hauen. ein muster, das für mich alles entmystifiziert hat: wenn du async-aufrufe verkettst, stütz dich auf `tokio::spawn` oder nutze `.await`-ketten konsistent, damit du nicht geliehene referenzen mit async-grenzen vermischst.
etwas praktisches zum ausprobieren - schreib auf, welche daten deine async-funktion über awaits hinweg behalten muss, und gib dann nur die explizit weiter. gib keine referenzen weiter, wenn du owned values weitergeben kannst. ja, manchmal fühlt sich das verschwenderisch an, aber es zwingt dich, das lifetime-problem zu verstehen, statt mit fehlermeldungen zu kämpfen. spiel auch im playground (play.rust-lang.org) mit kleinen beispielen rum, bevor du dich an echten code machst - manchmal zeigt dir ein 5-zeiliger test fall schneller, was schiefgeht, als das debuggen deines hauptprojekts.
Das, was bei mir endlich Klick gemacht hat, war zu verstehen, dass Async-Funktionen nicht wirklich das zurückgeben, was in der Signatur steht - sie geben ein Future zurück, das *irgendwann* diesen Wert produzieren wird, und der Borrow Checker muss wissen, dass jede Referenz, die du hältst, noch gültig sein wird, wenn dieses Future tatsächlich läuft. Ich habe Wochen damit verbracht, mit Lifetime-Fehlern in verschachtelten Async-Aufrufen zu kämpfen, bis ich anfing, aufzuschreiben, welche Daten jeder `.await`-Punkt benötigte - fast so, als würde ich den Lifecycle des Future laut vor mir hin erzählen. Versuch das Tokio-Tutorial und vor allem deren Abschnitt zum Spawnen von Tasks - konkrete Beispiele zu sehen, was in einen gespawnten Task verschoben wird versus was über Await-Punkte hinweg ausgeliehen wird, hat viel mehr geholfen als abstrakte Erklärungen. Das Async-Kapitel im Rust Book hat sich auch verbessert, also überspring es nicht, auch wenn du Teile des Hauptbuches bereits gelesen hast.
Anmeldenzum Beantworten.
