小编Mat*_*vid的帖子

为什么这段代码不能编译？

use std::{fs, path::Path};

fn main() {
    let dir = Path::new("../FileSystem");

    if !dir.is_dir() {
        println!("Is not a directory");
        return;
    }

    for item in try!(fs::read_dir(dir)) {
        let file = match item {
            Err(e) => {
                println!("Error: {}", e);
                return;
            }
            Ok(f) => f,
        };

        println!("");
    }

    println!("Done");
}

这是我得到的错误

error[E0308]: mismatched types
  --> src/main.rs:11:17
   |
11 |     for item in try!(fs::read_dir(dir)) {
   |                 ^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum `std::result::Result`
   |
   = note: expected type `()`
              found type `std::result::Result<_, _>`
   = note: …

我正在学习Node.js,我已经读过Node.js是单线程和非阻塞的.

我有一个良好的JavaScript背景,我确实理解回调,但我真正不了解的是Node.js如何可以单线程并在后台运行代码.这不矛盾吗？

因为如果Node.js是单线程的,那么它仍然只能执行一个任务.因此,如果它在后台运行某些东西,它必须停止当前任务在后台处理某些东西,对吗？

这实际上是如何工作的？

我想了解所有权和借贷的概念.起初我觉得一旦你理解它就很简单了.但...

fn main() {
    let a = 5;

    let _y = double(a);
    println!("{}", a);
}

fn double(x: i32) -> i32 {
    x * 2
}

起初我原本以为这不会编译,因为a本来会被移动到_y.

我有点困惑,但我发现我会是正确的,除了这i32是规则的一个例外,因为它实现了复制特征.

我查看了这个Copy特性,据我了解,它们列出了在底部实现此特征的所有类型.

所以bool类型不存在,所以我认为它的默认行为是"移动".但...

fn main() {
    let a = true;

    let _y = change_truth(a);
    println!("{}", a);
}

fn change_truth(x: bool) -> bool {
    !x
}

也不会失败.

现在我很困惑.我发现这个Clone特征似乎与复制特征密切相关.但除非我错过了,否则他们在学习文档中并没有真正提及它.

有人可以给我更多信息吗？

更新:

1. 我在Rust存储库上提交了一个问题.
2. 我还提出了一些拉动请求,其中包含一些变更建议.

为了在Rust中编写另一个lint,我需要确保Expr的类型实际上是一个Option<_>(或任何一个指针).我已经完成了任何ptrs和rptrs的结论,并rustc::middle::ty在我的测试用例调试中留下了一个(手动格式化以获得更好的可读性):

TyS { 
  sty: ty_enum(
    DefId { 
      krate: 2, 
      node: 117199 
    }, 
    Substs { 
      types: VecPerParamSpace {
        TypeSpace: [
          TyS { 
            sty: ty_int(i32), 
            flags: 0, 
            region_depth: 0 
          }
        ],
        SelfSpace: [], 
        FnSpace: [], 
      }, 
      regions: NonerasedRegions(
        VecPerParamSpace {
          TypeSpace: [], 
          SelfSpace: [], 
          FnSpace: [], 
        }
      )
    }
  ), 
  flags: 0, 
  region_depth: 0 
}

但是,现在我有点迷失了 - 我怎么知道TyS是否实际上是一个Option <_>类型？

有没有一种简单的方法可以知道我们在for循环中完成了多少次迭代？

如果我有这个代码

for line in lines {
    println!("{}: {}", linenumber, line);
}

我怎样才能轻松获得这个号码linenumber？我需要使用外部计数器变量吗？

我开始了一个新项目，我希望在其中尽可能地模块化，这意味着我希望将来能够将某些零件替换为其他零件。traits目前，我有以下代码，这似乎是的完美用法：

mod parser;
mod renderer;
mod renderers;

use parser::MarkParser;
use renderer::MarkRenderer;

struct Rustmark <P: MarkParser, R: MarkRenderer> {
    parser: P,
    renderer: R,
}


impl <P: MarkParser, R: MarkRenderer> Rustmark <P, R> {
    fn new() -> Rustmark <P, R> {
        Rustmark {
            parser: parser::DefaultParser::new(),
            renderer: renderers::HTMLRenderer::new(),
        }
    }

    fn render(&self, input: &str) -> &str {
        self.renderer.render(self.parser.parse(input))
    }
}

但是我遇到了两个错误，主要是这个错误：

错误：类型不匹配：预期Rustmark<P, R>，找到Rustmark<parser::DefaultParser, renderers::html::HTMLRenderer> （预期类型参数，找到结构parser::DefaultParser）[E0308]

还有一些像这样的终身错误：

错误：由于需求冲突，无法推断自动强制的适当寿命

帮助：考虑使用显式的生命周期参数，如下所示：fn parse<'a>(&'a self, input: &'a …

在以下两个摘要之间，哪个是更好的/首选的？

fn main() {
    let pair = 7;

    match pair {
        pair if pair > 5 => println!("Yeah"),
        _ => println!("No"),
    }
}

fn main() {
    let pair = 7;

    match pair {
        _ if pair > 5 => println!("Yeah"),
        _ => println!("No"),
    }
}

有没有更好的方法来编写此代码？因为这不起作用：

fn main() {
    let pair = 7;

    match pair {
        > 5 => println!("Yeah"),
        _ => println!("No"),
    }
}

我正在尝试使用泛型,但我不能很好地掌握该主题,并且我收到此错误:

error: mismatched types:
expected `book::mdbook::MDBook<R>`,
found `book::mdbook::MDBook<renderer::html_handlebars::HtmlHandlebars>`
(expected type parameter,
found struct `renderer::html_handlebars::HtmlHandlebars`) [E0308]

这是相关的代码

pub struct MDBook<R> where R: Renderer {
    title: String,
    author: String,
    config: BookConfig,
    pub content: Vec<BookItem>,
    renderer: R,
}

impl<R> MDBook<R> where R: Renderer {

    pub fn new(path: &PathBuf) -> Self {

        MDBook {
            title: String::from(""),
            author: String::from(""),
            content: vec![],
            config: BookConfig::new()
                        .set_src(path.join("src"))
                        .set_dest(path.join("book")),
            renderer: HtmlHandlebars::new(), // <---- ERROR HERE
        }
    }
}

该Renderer特征目前是空的,实现HtmlHandlebars是

pub struct HtmlHandlebars;

impl Renderer for …