这是Rust的assert_eq!宏实现.为简洁起见,我只复制了第一个分支:
macro_rules! assert_eq {
($left:expr, $right:expr) => ({
match (&$left, &$right) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
panic!(r#"assertion failed: `(left == right)`
left: `{:?}`,
right: `{:?}`"#, left_val, right_val)
}
}
}
});
}
这里的目的是match什么？为什么不检查不平等？
我正在尝试开发一个消息路由应用程序.我已经阅读了正式的Rust文档和一些文章,并认为我得到了指针,拥有和借用的东西如何工作,但意识到我没有.
use std::collections::HashMap;
use std::vec::Vec;
struct Component {
address: &'static str,
available_workers: i32,
lang: i32
}
struct Components {
data: HashMap<i32, Vec<Component>>
}
impl Components {
fn new() -> Components {
Components {data: HashMap::new() }
}
fn addOrUpdate(&mut self, component: Component) -> &Components {
if !self.data.contains_key(&component.lang) {
self.data.insert(component.lang, vec![component]);
} else {
let mut q = self.data.get(&component.lang); // this extra line is required because of the error: borrowed value does not live long enough
let mut queue = q.as_mut().unwrap();
queue.remove(0); …很难在文档中找到它.这可能是一个两部分问题:
是{integer}和{float}特定原始类型的某种语言别名？
在编译/语法错误消息中用大括号括起类型名称是什么意思？
例:
错误:没有为当前范围中的
pow类型命名的方法{integer}
我试图迭代stdin中的字符.该Read.chars()方法实现了这一目标,但不稳定.显而易见的替代方法是使用Read.lines()a flat_map将其转换为字符迭代器.
这似乎应该有效,但不会,导致borrowed value does not live long enough错误.
use std::io::BufRead;
fn main() {
let stdin = std::io::stdin();
let mut lines = stdin.lock().lines();
let mut chars = lines.flat_map(|x| x.unwrap().chars());
}
这在Rust中的逐字符读取文件中提到,但它并没有真正解释原因.
我特别困惑的是它与文档中flat_map的示例有何不同,后者用于flat_map应用于.chars()字符串向量.我真的不明白这应该有什么不同.我看到的主要区别是我的代码也需要调用unwrap(),但是将最后一行更改为以下代码也不起作用:
let mut chars = lines.map(|x| x.unwrap());
let mut chars = chars.flat_map(|x| x.chars());
它在第二行失败,所以问题似乎不是unwrap.
为什么最后一行不起作用,当文档中非常相似的行没有？有没有办法让这个工作？
我正在通过TCP编写聊天服务器作为学习项目.我受够了被修补WS箱子今天,但我遇到的一个问题.这是我编写的代码,修改了他们的服务器示例.
extern crate ws;
extern crate env_logger;
use ws::listen;
fn main() {
// Setup logging
env_logger::init().unwrap();
// Listen on an address and call the closure for each connection
if let Err(error) = listen("127.0.0.1:3012", |out| {
let mut message: String;
// The handler needs to take ownership of out, so we use move
move |message| {
message = message.trim();
// Handle messages received on this connection
println!("Server got message '{}'. ", message);
// Use the out channel …所以我在这里有这个示例代码：
use std::iter::Filter;
use std::slice::Iter;
fn main() {
let numbers = vec![12i32, 26, 31, 56, 33, 16, 81];
for number in ends_in_six(numbers) {
println!("{}", number);
}
}
fn ends_in_six(numbers: Vec<i32>) /* -> ??? */ {
numbers.iter().filter(|&n| *n % 10 == 6)
}
我正在尝试返回一个迭代器，从我收集到的内容来看，它在 Rust 中一直很麻烦。在这里运行代码给了我这个错误：
<anon>:13:5: 13:45 error: mismatched types:
expected `()`,
found `core::iter::Filter<core::slice::Iter<'_, i32>, [closure <anon>:13:27: 13:44]>`
(expected (),
found struct `core::iter::Filter`) [E0308]
<anon>:13 numbers.iter().filter(|&n| *n % 10 == 6)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现在，解决这个问题（并且基于我对这一切如何运作的相对有限的知识），似乎我应该做一些类似的事情：
fn ends_in_six<'a>(numbers: Vec<i32>) -> Filter<Iter<'a, …这段代码不会编译：
fn main() {
let m1 = vec![1, 2, 3];
let m2 = vec![&m1, &m1, &m1];
let m3 = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
for i in &m2 {
for j in i {
println!("{}", j);
}
}
for i in &m3 {
for j in i {
println!("{}", j);
}
}
}
fn main() {
let m1 = vec![1, 2, 3];
let m2 = vec![&m1, &m1, &m1];
let m3 = vec![vec![1, 2, 3], vec![4, 5, …我在实现这个Error特性时遇到了问题.我想从Diesel或其他数据库驱动程序中包装错误.我甚至没有接近实施,From因为我已经失败了实施Error.导致代码无法编译的行是代码块最后的那一行.
use std::fmt;
use std::error::{self, Error};
#[derive(Debug)]
pub enum MyError {
NotFound(String),
PersistenceError(Box<Error + Send + Sync>),
}
pub type MyResult<T> = Result<T, MyError>;
impl fmt::Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MyError::NotFound(ref msg) => write!(f, "Not found: {}", msg),
MyError::PersistenceError(ref cause) => write!(f, "Persistence error: {}", cause),
}
}
}
impl Error for MyError {
fn description(&self) -> &str {
match *self {
MyError::NotFound(ref msg) …在阅读Rust的convert.rs时,我遇到了以下代码:
#[unstable(feature = "try_from", issue = "33417")]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum Infallible {}
#[unstable(feature = "try_from", issue = "33417")]
impl fmt::Display for Infallible {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
match *self {
}
}
}
Infallible是一个空的枚举,没有变种.什么match *self {}回报？
我正在尝试编写一个函数来接收字符串向量的向量,并返回连接在一起的所有向量,即它返回一个字符串向量.
到目前为止我能做的最好的事情如下:
fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
let vals : Vec<&String> = vecs.iter().flat_map(|x| x.into_iter()).collect();
vals.into_iter().map(|v: &String| v.to_owned()).collect()
}
但是,我对这个结果不满意,因为看起来我应该能够Vec<String>从第一次collect调用中获得,但不知怎的,我无法弄清楚如何做到这一点.
我更感兴趣的是弄清楚为什么返回类型collect是正确的Vec<&String>.我试图从API文档和源代码中推断出这一点,但尽管我付出了最大的努力,我甚至无法理解函数的签名.
所以让我尝试跟踪每个表达式的类型:
- vecs.iter(): Iter<T=Vec<String>, Item=Vec<String>>
- vecs.iter().flat_map(): FlatMap<I=Iter<Vec<String>>, U=???, F=FnMut(Vec<String>) -> U, Item=U>
- vecs.iter().flat_map().collect(): (B=??? : FromIterator<U>)
- vals was declared as Vec<&String>, therefore
vals == vecs.iter().flat_map().collect(): (B=Vec<&String> : FromIterator<U>). Therefore U=&String.
我假设上面的类型推断器能够U=&String根据类型来确定vals.但是如果我在代码中给表达式赋予显式类型,则编译时没有错误:
fn concat_vecs(vecs: Vec<Vec<String>>) -> Vec<String> {
let a: Iter<Vec<String>> = vecs.iter(); …