Hacktoberfest 2026: die Issues, die Maintainer für den Oktober markiert haben – offen und einsteigerfreundlich. Hacktoberfest-Issues durchsuchen

Cannot change path of Uri with less than two failure branches

Offen
  • Stimmt etwas nicht?
#594 3 Kommentare 2 Reaktionen 0 zugewiesene Personen Auf GitHub ansehen

Dieses Issue hat noch niemand übernommen.

Bewertung

Schwierigkeit
5/5
Geschätzter Aufwand
Über eine Woche
Anfängerfreundlichkeit
35/100
Issue-Typ
Feature
Klarheit
Größtenteils klar
Aktivitätsstatus
Veraltet
Tech-Stack
rust
Bereich
api

Rechercherichtung

Beginne damit, die im Issue beschriebenen vorhandenen APIs http::uri::Builder, Uri::into_parts, Parts und path_and_query zu lesen. Vergleiche die vorgeschlagenen Designs für from_uri und from_parts und bestimme anschließend, welches das bestehende Fehlermodell beibehält und mit der Builder-API konsistent ist. Als erledigt gilt die Aufgabe, wenn ein abgestimmtes und geprüftes API-Design vorliegt, nicht eine Implementierung auf Grundlage einer ungelösten Alternative.

Vom Indexierungsmodell aus dem Issue-Text verfasst.

Beschreibung

I have a many scenarios where I have one Uri and want to change its path_and_query, but this doesn't seem possible without writing code that can yield at least two distinct errors.

This doesn't make sense; realistically, only one error can occur: that the path_and_query is invalid. Beyond that, the operation should be infallible.

Here's one approach that I tried:

    // self.base_url is of type `Uri`
    pub fn relative_uri(&self, path: &str) -> Result<Uri, XXX> {
        let mut parts = self.base_url.clone().into_parts();
        parts.path_and_query = Some(path.try_into().unwrap());
        Uri::from_parts(parts).unwrap()
    }

Because there's two possible error types here (http::uri::InvalidUriParts or http::uri::InvalidUri), I need to have an enum error type for this function that can be either of both variants (or Box it, or wrap it in some common type).

This makes my API a mess because now callers need to handle two distinct error types (or a container of various types) for an operation that, realistically, can only fail in a single way (the path_and_query supplied is invalid).

I tried using the Builder pattern, but the type returned by hyper::Uri::scheme cannot passed to http::uri::Builder::scheme, so I end up with a bunch of failure branches again.

These three approaches could work around the issue:

  • Mutate an Uri and change its path_and_query, or
  • Create a new Uri using the Parts from another while changing only one part.
  • Allow creating a builder pre-populated with Parts from an existing Uri. This would allow re-writing the above example in a way that only one error needs to be handled.

The first one has been mentioned in the past and it seems its undesirable, so I'll just ignore it. The second is tricky to design with a clean API. The third is probably the simplest, since the builder can be initialized with the parts from the source Uri.

I think something like this is quite viable:

impl Builder {
    // ...
    pub fn from_uri(uri: Uri) -> Self {
        Builder {
            parts: Ok(uri.into_parts()),
        }
    }

This could then be used as:

        Builder::from_uri(my_uri)
            .path_and_query(path)
            .build()
            .unwrap();

Note that there's only one failure branch (and one error type) that needs to be handled.

Though, perhaps the following is as simple, useful and a bit more correct:

impl Builder {
    // ...
    pub fn from_parts(parts: Parts) -> Self {
        Builder {
            parts: Ok(parts),
        }
    }
Vorherrschende Sprache
Rust
Sterne
1.4k
Forks
385
Ø Merge
1 T. 5 Std.
Gemergte PRs (30 T.)
2

Entwicklungsumgebung

Dieses Projekt bietet weder Dev-Container noch Dockerfile noch Beitragsleitfaden – die Einrichtung liegt bei Ihnen. Beginnen Sie mit der README; die allgemeinen Schritte stehen in unserem Leitfaden für den ersten Beitrag.

Erste Schritte

  1. Lesen Sie das ganze Issue und danach den Beitragsleitfaden des Projekts.
  2. Schreiben Sie ins Issue, dass Sie es übernehmen — das erspart doppelte Arbeit.
  3. Forken Sie das Repository und arbeiten Sie in einem Branch.
  4. Öffnen Sie einen Pull Request, der die Issue-Nummer nennt.

Mehr aus hyperium/http

Alle Issues in hyperium/http

Ähnliche Issues

Weitere Issues zu Rust

Neue Issues direkt in Ihr Postfach

Eine kurze Übersicht über anfängerfreundliche GitHub-Issues.