[英]How do I implement FromStr with a concrete lifetime?
I want to implement FromStr
for a struct with a lifetime parameter:我想为具有生命周期参数的结构实现
FromStr
:
use std::str::FromStr;
struct Foo<'a> {
bar: &'a str,
}
impl<'a> FromStr for Foo<'a> {
type Err = ();
fn from_str(s: &str) -> Result<Foo<'a>, ()> {
Ok(Foo { bar: s })
}
}
pub fn main() {
let foo: Foo = "foobar".parse().unwrap();
}
However, the compiler complains:但是,编译器抱怨:
error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
--> src/main.rs:11:12
|
11 | Ok(Foo { bar: s })
| ^^^
|
help: consider using an explicit lifetime parameter as shown: fn from_str(s: &'a str) -> Result<Foo<'a>, ()>
--> src/main.rs:9:5
|
9 | fn from_str(s: &str) -> Result<Foo<'a>, ()> {
| ^
Changing the impl to将 impl 更改为
impl<'a> FromStr for Foo<'a> {
type Err = ();
fn from_str(s: &'a str) -> Result<Foo<'a>, ()> {
Ok(Foo { bar: s })
}
}
gives this error给出这个错误
error[E0308]: method not compatible with trait
--> src/main.rs:9:5
|
9 | fn from_str(s: &'a str) -> Result<Foo<'a>, ()> {
| ^ lifetime mismatch
|
= note: expected type `fn(&str) -> std::result::Result<Foo<'a>, ()>`
= note: found type `fn(&'a str) -> std::result::Result<Foo<'a>, ()>`
note: the anonymous lifetime #1 defined on the block at 9:51...
--> src/main.rs:9:52
|
9 | fn from_str(s: &'a str) -> Result<Foo<'a>, ()> {
| ^
note: ...does not necessarily outlive the lifetime 'a as defined on the block at 9:51
--> src/main.rs:9:52
|
9 | fn from_str(s: &'a str) -> Result<Foo<'a>, ()> {
| ^
help: consider using an explicit lifetime parameter as shown: fn from_str(s: &'a str) -> Result<Foo<'a>, ()>
--> src/main.rs:9:5
|
9 | fn from_str(s: &'a str) -> Result<Foo<'a>, ()> {
| ^
I don't believe that you can implement FromStr
in this case.我不相信你可以在这种情况下实现
FromStr
。
fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err>;
There's nothing in the trait definition that ties the lifetime of the input to the lifetime of the output.特征定义中没有任何内容将输入的生命周期与输出的生命周期联系起来。
Not a direct answer , but I'd just suggest making a constructor that accepts the reference:不是直接回答,但我只是建议制作一个接受参考的构造函数:
struct Foo<'a> {
bar: &'a str
}
impl<'a> Foo<'a> {
fn new(s: &str) -> Foo {
Foo { bar: s }
}
}
pub fn main() {
let foo = Foo::new("foobar");
}
This has the side benefit of there not being any failure modes - no need to unwrap
.这样做的附带好处是没有任何故障模式 - 无需
unwrap
。
You could also just implement From
:你也可以只实现
From
:
struct Foo<'a> {
bar: &'a str,
}
impl<'a> From<&'a str> for Foo<'a> {
fn from(s: &'a str) -> Foo<'a> {
Foo { bar: s }
}
}
pub fn main() {
let foo: Foo = "foobar".into();
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.