無法爲`rayon`

Question

找到箱子，我嘗試使用並行找到BST的直徑：

extern crate rayon; 

use std::cmp::Ordering::*; 
use std::ops::Index; 
use rayon::prelude::*; 

#[derive(Debug)] 
struct Node<K> { 
    left: Option<Box<Node<K>>>, 
    right: Option<Box<Node<K>>>, 
    key: K, 
} 

impl<K> Node<K> { 
    fn new(k: K) -> Node<K> { 
     Node { 
      left: None, 
      right: None, 
      key: k, 
     } 
    } 
} 

impl<K: Ord> Node<K> { 
    fn insert(&mut self, n: Node<K>) { 
     match n.key.cmp(&self.key) { 
      Less => { 
       match self.left { 
        None => self.left = Some(Box::new(n)), 
        Some(ref mut l) => l.insert(n), 
       } 
      } 
      Greater => { 
       match self.right { 
        None => self.right = Some(Box::new(n)), 
        Some(ref mut r) => r.insert(n), 
       } 
      } 
      _ => {} 
     } 
    } 

    fn height(&self) -> u32 { 
     let mut left_he = 1; 
     if let Some(ref l) = self.left { 
      left_he = 1 + l.height() 
     } 
     let mut right_he = 1; 
     if let Some(ref r) = self.right { 
      right_he = 1 + r.height() 
     } 
     if left_he > right_he { 
      return left_he; 
     } 
     return right_he; 
    } 

    fn rec(&self) -> u32 { 
     let mut le = 0; 
     if let Some(ref l) = self.left { 
      le = l.height() 
     } 
     let mut re = 0; 
     if let Some(ref r) = self.right { 
      re = r.height() 
     } 
     let hei = le + re + 1; 
     let mut led = 0; 
     let mut red = 0; 

     let Some(ref l) = self.left; 

     let Some(ref r) = self.right; 

     rayon::join(|| led = l.rec(), || red = r.rec()); 

     let greater_diameter; 
     if red > led { 
      greater_diameter = red; 
     } else { 
      greater_diameter = led; 
     } 

     if hei > greater_diameter { 
      return hei; 
     } 
     return greater_diameter; 
    } 

    fn print_recursive(nodes: Vec<&Self>) { 
     let mut v: Vec<&Self> = vec![]; 
     for n in nodes { 
      print!("1 "); 
      match n.left { 
       None => {} 
       Some(ref l) => v.push(&*l), 
      } 
      match n.right { 
       None => {} 
       Some(ref r) => v.push(&*r), 
      } 
     } 
     println!(""); 
     if v.len() > 0 { 
      Node::print_recursive(v); 
     } 
    } 
} 

#[derive(Debug, Default)] 
struct Bst<K> { 
    root: Option<Box<Node<K>>>, 
} 
impl<K> Bst<K> { 
    fn new() -> Bst<K> { 
     Bst { root: None } 
    } 
} 

impl<K: Ord> Bst<K> { 
    fn insert(&mut self, k: K) { 
     match self.root { 
      None => self.root = Some(Box::new(Node::new(k))), 
      Some(ref mut r) => r.insert(Node::new(k)), 
     } 
    } 

    fn rec(&self) -> u32 { 
     match self.root { 
      None => 0, 
      Some(ref r) => r.rec(), 
     } 
    } 

    fn print(&self) { 
     match self.root { 
      None => {} 
      Some(ref r) => Node::print_recursive(vec![&*r]), 
     }; 
    } 
} 

fn main() { 
    let mut bst1 = Bst::new(); 

    bst1.insert(20); 
    bst1.insert(21); 
    bst1.insert(22); 
    bst1.insert(23); 
    bst1.insert(24); 
    bst1.insert(25); 
    bst1.insert(19); 
    bst1.insert(18); 
    bst1.insert(17); 
    bst1.insert(16); 
    bst1.insert(15); 
    bst1.insert(14); 
    bst1.print(); 

    println!("{}", bst1.rec()); 
} 

當我編譯（rustc code.rs），它顯示

error: can't find crate for `rayon` [E0463] 

我鏽病版本是rustc 1.8.0 (db2939409 2016-04-11)

Answer 1

你不能在不告訴編譯器到哪裏找到它的情況下使用外部依賴。最簡單的方法是創建Cargo.toml文件，然後使用cargo build直接編譯項目而不是rustc。

要創建Cargo.toml文件，你可以去到項目目錄和類型：

cargo init --bin 

這將做兩件事情：

1. 創建文件src/main.rs。你應該把你的代碼放在這裏。
2. 創建Cargo.toml文件，該文件使用的貨物存儲依賴和其他構建信息

然後，您可以編輯Cargo.toml添加rayon依賴。 crates.io page for rayon爲您提供確切的信息，你可以在那裏粘貼。當你做了，就應該是這個樣子：

[package] 
name = "foo" 
version = "0.1.0" 
authors = ["singh <singh@singh.com>"] 

[dependencies] 
rayon = "0.3.1" 

一旦你有了這個之後，就可以生成項目：

cargo build 

或者與運行：

cargo run 

您可以通過Cargo guide獲取更多信息。