Aké sú dôvody pre funkciu FromStr not expose lifetime? - hrdza, vlastnosti, životnosť

Rust FromStr znak je definovaný takto

pub trait FromStr {
type Err;
fn from_str(s: &str) -> Result<Self, Self::Err>;
}

Nehovorí jeho životnosť a nie je možné implementovať túto vlastnosť pre niečo, čo obsahuje odkaz na zdrojový reťazec, napríklad:

struct MyIterator<"a> {
cur_pointer: &"a str
}

impl<"a> FromStr for MyIterator<"a> {
type Err = i32;
fn from_str(s: &"a str) -> Result<Self, Self::Err> {
Ok(MyIterator { cur_pointer: s })
}
}

dáva chybu

method `from_str` has an incompatible type for trait: expected bound lifetime parameter , found concrete lifetime [E0053]

Zďaleka som nenašiel žiadny spôsob, ako implementovať FromStr preMyIterator. Predpokladám, že je to preto, že pôvodná vlastnosť nevyvolala životnosť reťazca v jeho parametroch. Moja prvá otázka znie: mám pravdu, že neexistuje spôsob, ako implementovať FromStr pre MyIterator? Ak som "m zle, čo je to spôsob, ako to urobiť (za predpokladu, že MyIterator chce zachovať odkaz na pôvodný reťazec)?

Teraz som našiel iba túto otázku: Ako môžem implementovať FromStr s konkrétnou životnosťou?, ale najlepšia odpoveď začína slovami "Ja neverím, že môžete realizovať", takže chcem mať istotu, že je to naozaj nemožné v Rust 1.0.0.

Ak bola definícia zvláštnosti taká:

trait MyFromStr<"a> {
type Err;
fn from_str(s: &"a str) -> Result<Self, Self::Err>;
}

je možné ho implementovať pre typy obsahujúce odkazy na pôvodný reťazec a neobsahujúce odkazy na pôvodný reťazec:

struct MyIterator<"a> {
cur_pointer: &"a str
}

impl<"a> MyFromStr<"a> for MyIterator<"a> {
type Err = i32;
fn from_str(s: &"a str) -> Result<Self, Self::Err> {
Ok(MyIterator { cur_pointer: s })
}
}

struct MyCopy {
val: String
}

impl<"a> MyFromStr<"a> for MyCopy {
type Err = i32;
fn from_str(s: &"a str) -> Result<Self, Self::Err> {
Ok(MyCopy { val: s.to_string() })
}
}

Moja druhá otázka znie: je nejaký konkrétny dôvod, prečo vlastnosť FromStr nevystavuje život? Možno, že som nepochopil niečo o životoch a odhalil život má nevýhody?

odpovede:

3 pre odpoveď č. 1

Zahrnutie životnosti robí tento znak zložitejším a presnejšie povedané, generický kód používa túto vlastnosť podrobnejšie (prenáša nepotrebnú životnosť). fn foo<T: FromStr> by som už nefungujú.

Je to tiež zbytočné pre zamýšľané použitie reťazcov analyzovať z reťazca a použiť výsledok bez obáv o reťazec. Je to určite jednoduchšie, aby kód tak. Mnoho typov don 't potrebujú život tak ako tak (pozri dlhý zoznam typov, ktoré ho implementujú).

Nemôžete implementovať FromStr pre tento typ. Čo môžete urobiť, je

impl<"a> From<&"a str> for MyIterator<"a> { ... }

To vám dáva veľa generických konverzných strojov, nie nie je metóda str::parse(), Možno názov tejto metódy je ďalším argumentom pre vynechanie celého života.

---