[英]How can I make my Rust function more generic & efficient?
我有一个有效的功能,但比我想要的更专业,并且效率低下,我想解决这个问题。
工作但有缺陷的功能:
fn iter_to_min<T>(i:T) -> i64 where T:Iterator<Item=String>{
i.collect::<Vec<String>>()
.iter()
.flat_map(|s|s.split_whitespace())
.map(str::trim)
.map(str::parse::<i64>)
.map(Result::unwrap)
.min()
.expect("No min found.")
}
我不喜欢这种实现的原因是:
i64
是硬编码的,我想为u64
和其他返回类型重用此函数 flat_map
的闭包可能不会被LLVM优化掉 最接近我的理想功能:
use std::str::FromStr;
fn iter_to_min<T,U>(i:T) -> U where T:Iterator<Item=String>,U: Ord+FromStr{
i.flat_map(str::split_whitespace)
.map(str::trim)
.map(str::parse::<U>)
.map(Result::unwrap)
.min()
.expect("No min found.")
}
我看到的问题是:
str::split_whitespace
的参数是一个String
,不会强制转换为str
str::split_whitespace
的参数不知道活得足够长 Result::unwrap
不会抱怨特性core::fmt::Debug
没有为类型<U as core::str::FromStr>::Err
我认为,通过聪明的终身记谱法和特质要求,至少有两个可以修复,而且谁知道可能有三种方式去三。
使用一些建议修复的示例代码:
use std::io::BufRead;
use std::str::FromStr;
use std::fmt::Debug;
fn iter_to_min<T,U>(i:T) -> U where T:Iterator<Item=String>,U: Ord+FromStr, U::Err: Debug{
i.collect::<Vec<String>>()
.iter()
.flat_map(|s|s.split_whitespace())
.map(str::trim)
.map(str::parse::<U>)
.map(Result::unwrap)
.min()
.expect("No min found.")
}
fn main() {
let a: Vec<_> = std::env::args().skip(1).collect();
let m:i64 = if a.is_empty() {
let s = std::io::stdin();
let m = iter_to_min(s.lock().lines().map(Result::unwrap));
m
}else{
iter_to_min(a.into_iter())
};
println!("{}", m);
}
不幸的是,在保持通用性和缺少分配时,没有办法做你想做的事。 原因是你需要有人拥有你的字符串数据,但是如果在拥有字符串的迭代器上执行flat_map(str::split_whitespace)
,那么就没有人可以保留这些拥有的字符串,因为str::split_whitespace
只能借用字符串被调用。 但是,如果您将所有权“推”到调用链上,则您将无法完全通用并按值接受所拥有的字符串。
因此,有两种解决方案:将整个迭代器预收集到Vec<String>
(或者将split_whitespace()
产生的项分别转换为拥有的字符串并再次将它们收集到Vec
),或接受引用的迭代器。
这是我能想出的第一个解决方案中最通用的版本:
use std::str::FromStr;
use std::fmt::Debug;
fn iter_to_min<S, T, U>(i: T) -> U
where S: Into<String>,
T: IntoIterator<Item=S>,
U: Ord + FromStr,
U::Err: Debug
{
i.into_iter()
.map(Into::into)
.collect::<Vec<_>>()
.iter()
.flat_map(|s| s.split_whitespace())
.map(str::parse::<U>)
.map(Result::unwrap)
.min()
.expect("No min found")
}
( 在这里试试)
它与您的第一个基本相同,但更通用。 另请注意,您不需要在split_whitespace()
之后修剪字符串的部分 - 后者将确保字符串的各个部分在其侧面没有空格。 Into<String>
绑定允许一个传递&str
和String
迭代器,在后一种情况下,不会执行额外的副本。
或者,您可以将每行分成独立的字符串:
fn iter_to_min<S, T, U>(i: T) -> U
where S: AsRef<str>,
T: IntoIterator<Item=S>,
U: Ord + FromStr,
U::Err: Debug
{
i.into_iter()
.flat_map(|s| s.as_ref().split_whitespace().map(String::from).collect::<Vec<_>>())
.map(|s| s.parse::<U>())
.map(Result::unwrap)
.min()
.expect("No min found")
}
这里我们只需要从迭代器项中获取一个&str
,而不是String
,所以我使用了AsRef<str>
。 但是,每行不仅必须转换为String
s序列; 由于与上述完全相同的原因,必须将此序列收集到一个向量中 - 否则将无法保持S
类型的原始值不被破坏。
但它有可能避免.map(String::from).collect::<Vec<_>>()
如果你愿意损失一些通用性,虽然。 这是我上面提到的第二个解决方案。 我们可以在引用上接受迭代器:
fn iter_to_min<'a, S: ?Sized, T, U>(i: T) -> U
where S: AsRef<str> + 'a,
T: IntoIterator<Item=&'a S>,
U: Ord + FromStr,
U::Err: Debug
{
i.into_iter()
.map(AsRef::as_ref)
.flat_map(str::split_whitespace)
.map(|s| s.parse::<U>())
.map(Result::unwrap)
.min()
.expect("No min found")
}
( 在这里试试)
粗略地说,现在S
值由其他人拥有,并且它们的生命周期大于iter_to_min()
的范围,因此您既不需要将每个部分转换为String
也不需要将整个拆分结果收集到Vec<String>
。 但是,您将无法将Vec<String>
传递给此函数; 你将能够通过vec.iter()
,但是:
let v: Vec<String> = vec!["0".into(), "1".into()];
iter_to_min(v.iter())
在所有这些示例中,我已将Iterator
更改为IntoIterator
- 这几乎总是您想要使用的而不仅仅是Iterator
。 例如,它允许您直接将集合传递给此类函数。 其次,我添加了U::Err: Debug
条件,这是Result::unwrap
工作所必需的。 最后,要修复“String not coercing to&str`”的问题,你总是可以使用显式闭包和方法语法来为你做这种强制。
没有额外分配的解决方案
use std::str::FromStr;
fn iter_to_min<T, U>(i: T) -> Option<U>
where T: Iterator<Item = String>,
U: Ord + FromStr
{
i.filter_map(|string| {
string.split_whitespace()
.map(str::trim)
.map(str::parse::<U>)
.filter_map(Result::ok)
.min()
})
.min()
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.