rustlings 学习随笔

序言

rustlings 是一个关于rust的练习题的项目.可以帮助大家通过完成一个项目的方式练习rust的语法,我认为对于补充我rust现学现卖过程中的情况很有帮助.
下边是GPT对它的介绍:

Rustlings 是专为那些想要学习 Rust 编程语言的人设计的一个交互式练习集合。无论你是编程新手还是有经验的开发者，Rustlings 都能提供一个友好的环境来探索 Rust 的独特功能。
特点：

• 互动性: 通过实际编写代码并即时看到结果，你可以更好地理解 Rust 的工作原理。
  
• 渐进式难度: 练习按照难易程度排序，从基础到高级逐步引导你深入 Rust。
  
• 涵盖广泛: 练习覆盖了 Rust 的主要方面，包括所有权、借用、生命周期、错误处理等。
  
• 社区支持: 作为一个活跃的开源项目，Rustlings 拥有一个热情的支持社区，你可以在这里找到帮助或贡献自己的力量。
  
• 易于安装: 只需几个简单的命令，就可以在你的机器上设置好 Rustlings，并开始你的学习之旅。
  

structs2

1. // structs2.rs
2. //
3. // Address all the TODOs to make the tests pass!
4. //
5. // Execute `rustlings hint structs2` or use the `hint` watch subcommand for a
6. // hint.
8. // I AM NOT DONE
10. #[derive(Debug)]
11. struct Order {
12.     name: String,
13.     year: u32,
14.     made_by_phone: bool,
15.     made_by_mobile: bool,
16.     made_by_email: bool,
17.     item_number: u32,
18.     count: u32,
19. }
21. fn create_order_template() -> Order {
22.     Order {
23.         name: String::from("Bob"),
24.         year: 2019,
25.         made_by_phone: false,
26.         made_by_mobile: false,
27.         made_by_email: true,
28.         item_number: 123,
29.         count: 0,
30.     }
31. }
33. #[cfg(test)]
34. mod tests {
35.     use super::*;
37.     #[test]
38.     fn your_order() {
39.         let order_template = create_order_template();
40.         // TODO: Create your own order using the update syntax and template above!
41.         // let your_order =
42.         let your_order = Order {
43.             name: String::from("Hacker in Rust"),
44.             count: 1,
45.             ..order_template
46.         };
47.         assert_eq!(your_order.name, "Hacker in Rust");
48.         assert_eq!(your_order.year, order_template.year);
49.         assert_eq!(your_order.made_by_phone, order_template.made_by_phone);
50.         assert_eq!(your_order.made_by_mobile, order_template.made_by_mobile);
51.         assert_eq!(your_order.made_by_email, order_template.made_by_email);
52.         assert_eq!(your_order.item_number, order_template.item_number);
53.         assert_eq!(your_order.count, 1);
54.     }
55. }

复制代码

这里注意这个,这里有一个结构体更新语法的问题:

1. let your_order = Order {
2.             name: String::from("Hacker in Rust"),
3.             count: 1,
4.             ..order_template
5.         };

复制代码

string4

主要是分辨String和&str的区别.
hashmaps3

1. // hashmaps3.rs
2. //
3. // A list of scores (one per line) of a soccer match is given. Each line is of
4. // the form : "<team_1_name>,<team_2_name>,<team_1_goals>,<team_2_goals>"
5. // Example: England,France,4,2 (England scored 4 goals, France 2).
6. //
7. // You have to build a scores table containing the name of the team, goals the
8. // team scored, and goals the team conceded. One approach to build the scores
9. // table is to use a Hashmap. The solution is partially written to use a
10. // Hashmap, complete it to pass the test.
11. //
12. // Make me pass the tests!
13. //
14. // Execute `rustlings hint hashmaps3` or use the `hint` watch subcommand for a
15. // hint.
17. // I AM NOT DONE
19. use std::collections::HashMap;
21. // A structure to store the goal details of a team.
22. struct Team {
23.     goals_scored: u8,
24.     goals_conceded: u8,
25. }
27. fn build_scores_table(results: String) -> HashMap<String, Team> {
28.     // The name of the team is the key and its associated struct is the value.
29.     let mut scores: HashMap<String, Team> = HashMap::new();
31.     for r in results.lines() {
32.         let v: Vec<&str> = r.split(',').collect();
33.         let team_1_name = v[0].to_string();
34.         let team_1_score: u8 = v[2].parse().unwrap();
35.         let team_2_name = v[1].to_string();
36.         let team_2_score: u8 = v[3].parse().unwrap();
37.         // TODO: Populate the scores table with details extracted from the
38.         // current line. Keep in mind that goals scored by team_1
39.         // will be the number of goals conceded from team_2, and similarly
40.         // goals scored by team_2 will be the number of goals conceded by
41.         // team_1.
42.         let team_1 = scores.entry(team_1_name).or_insert(Team {
43.             goals_scored: 0,
44.             goals_conceded: 0,
45.         });
46.         team_1.goals_scored += team_1_score;
47.         team_1.goals_conceded += team_2_score;
48.         let team_2 = scores.entry(team_2_name).or_insert(Team {
49.             goals_scored: 0,
50.             goals_conceded: 0,
51.         });
52.         team_2.goals_scored += team_2_score;
53.         team_2.goals_conceded += team_1_score;
54.     }
55.     scores
56. }
58. #[cfg(test)]
59. mod tests {
60.     use super::*;
62.     fn get_results() -> String {
63.         let results = "".to_string()
64.             + "England,France,4,2\n"
65.             + "France,Italy,3,1\n"
66.             + "Poland,Spain,2,0\n"
67.             + "Germany,England,2,1\n";
68.         results
69.     }
71.     #[test]
72.     fn build_scores() {
73.         let scores = build_scores_table(get_results());
75.         let mut keys: Vec<&String> = scores.keys().collect();
76.         keys.sort();
77.         assert_eq!(
78.             keys,
79.             vec!["England", "France", "Germany", "Italy", "Poland", "Spain"]
80.         );
81.     }
83.     #[test]
84.     fn validate_team_score_1() {
85.         let scores = build_scores_table(get_results());
86.         let team = scores.get("England").unwrap();
87.         assert_eq!(team.goals_scored, 5);
88.         assert_eq!(team.goals_conceded, 4);
89.     }
91.     #[test]
92.     fn validate_team_score_2() {
93.         let scores = build_scores_table(get_results());
94.         let team = scores.get("Spain").unwrap();
95.         assert_eq!(team.goals_scored, 0);
96.         assert_eq!(team.goals_conceded, 2);
97.     }
98. }

复制代码

自动解引用

Deref 解引用 - Rust语言圣经(Rust Course)
所有权借用

#TODO
options2

1. // options2.rs
2. //
3. // Execute `rustlings hint options2` or use the `hint` watch subcommand for a
4. // hint.
6. // I AM NOT DONE
8. #[cfg(test)]
9. mod tests {
10.     #[test]
11.     fn simple_option() {
12.         let target = "rustlings";
13.         let optional_target = Some(target);
15.         // TODO: Make this an if let statement whose value is "Some" type
16.         if let Some(word) = optional_target {
17.             assert_eq!(word, target);
18.         }
19.     }
21.     #[test]
22.     fn layered_option() {
23.         let range = 10;
24.         let mut optional_integers: Vec<Option<i8>> = vec![None];
26.         for i in 1..(range + 1) {
27.             optional_integers.push(Some(i));
28.         }
30.         let mut cursor = range;
32.         // TODO: make this a while let statement - remember that vector.pop also
33.         // adds another layer of Option<T>. You can stack `Option<T>`s into
34.         // while let and if let.
35.         while let Some(Some(integer)) = optional_integers.pop() {
36.             assert_eq!(integer, cursor);
37.             cursor -= 1;
38.         }
40.         assert_eq!(cursor, 0);
41.     }
42. }

复制代码

这里注意pop本身返回的就是Option,而当初push进去的成员是Some(),因此导致了需要套两层Some来做模式匹配.
options3

这里存在一个所有权的问题:

1. // options3.rs
2. //
3. // Execute `rustlings hint options3` or use the `hint` watch subcommand for a
4. // hint.
6. // I AM NOT DONE
8. struct Point {
9.     x: i32,
10.     y: i32,
11. }
13. fn main() {
14.     let y: Option<Point> = Some(Point { x: 100, y: 200 });
16.     match y {
17.         Some(ref p) => println!("Co-ordinates are {},{} ", p.x, p.y),
18.         _ => panic!("no match!"),
19.     }
20.     y; // Fix without deleting this line.
21. }

复制代码

必须加上ref,不然会造成y本身因为被使用因此被move了所有权,那么match结束的时候就会被释放掉,因此只传入它的ref.
errors3

(名词)的传播
返回值 Result 和? - Rust语言圣经(Rust Course)
errors4

PartialEq Trait:

• PartialEq 是 Rust 标准库中的一个 trait，它允许你定义类型之间的相等性比较。
  
• 当你为一个结构体或枚举派生 PartialEq 时，编译器会自动生成一个 == 和 != 操作符的实现，这些操作符将基于结构体或枚举的所有字段进行逐个比较。
  
• 如果所有字段都相等，则认为这两个实例是相等的；如果有任何一个字段不相等，则认为它们不相等。
  

Debug Trait

• Debug 是另一个标准库中的 trait，它用于格式化调试输出。
  
• 当你为一个结构体或枚举派生 Debug 时，编译器会自动生成 fmt:ebug 的实现，这使得你可以使用 {:?} 或 {:#?} 格式说明符来打印该类型的实例。
  
• 这对于调试非常有用，因为它可以帮助你查看结构体或枚举实例的内容。
  

error5

1. // errors5.rs
2. //
3. // This program uses an altered version of the code from errors4.
4. //
5. // This exercise uses some concepts that we won't get to until later in the
6. // course, like `Box` and the `From` trait. It's not important to understand
7. // them in detail right now, but you can read ahead if you like. For now, think
8. // of the `Box<dyn ???>` type as an "I want anything that does ???" type, which,
9. // given Rust's usual standards for runtime safety, should strike you as
10. // somewhat lenient!
11. //
12. // In short, this particular use case for boxes is for when you want to own a
13. // value and you care only that it is a type which implements a particular
14. // trait. To do so, The Box is declared as of type Box<dyn Trait> where Trait is
15. // the trait the compiler looks for on any value used in that context. For this
16. // exercise, that context is the potential errors which can be returned in a
17. // Result.
18. //
19. // What can we use to describe both errors? In other words, is there a trait
20. // which both errors implement?
21. //
22. // Execute `rustlings hint errors5` or use the `hint` watch subcommand for a
23. // hint.
25. // I AM NOT DONE
27. use std::error;
28. use std::fmt;
29. use std::num::ParseIntError;
31. // TODO: update the return type of `main()` to make this compile.
32. fn main() -> Result<(), Box<dyn error::Error>> {
33.     let pretend_user_input = "42";
34.     let x: i64 = pretend_user_input.parse()?;
35.     println!("output={:?}", PositiveNonzeroInteger::new(x)?);
36.     Ok(())
37. }
39. // Don't change anything below this line.
41. #[derive(PartialEq, Debug)]
42. struct PositiveNonzeroInteger(u64);
44. #[derive(PartialEq, Debug)]
45. enum CreationError {
46.     Negative,
47.     Zero,
48. }
50. impl PositiveNonzeroInteger {
51.     fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {
52.         match value {
53.             x if x < 0 => Err(CreationError::Negative),
54.             x if x == 0 => Err(CreationError::Zero),
55.             x => Ok(PositiveNonzeroInteger(x as u64)),
56.         }
57.     }
58. }
60. // This is required so that `CreationError` can implement `error::Error`.
61. impl fmt::Display for CreationError {
62.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
63.         let description = match *self {
64.             CreationError::Negative => "number is negative",
65.             CreationError::Zero => "number is zero",
66.         };
67.         f.write_str(description)
68.     }
69. }
71. impl error::Error for CreationError {}

复制代码

这里是用dyn error::Error代表的是一个实现了error::Error的struct,而不需要知道这个struct的名字.那么这个对象由编译器在下文中寻找.
意思就是说我不管你这个对象叫什么,只需要实现这个Trait就行了,我需要用到的是你这个struct关于这个Trait的特征.
特征对象 - Rust语言圣经(Rust Course):

特征对象指向实现了 Draw 特征的类型的实例，也就是指向了 Button 或者 SelectBox 的实例，这种映射关系是存储在一张表中，可以在运行时通过特征对象找到具体调用的类型方法。
可以通过 & 引用或者 Box 智能指针的方式来创建特征对象。

那么Box是一种创建特征对象的方式.
对于Box智能指针本身,有解释,我的理解暂时是在堆上创建一个对象,可以看作包裹的内容是保存在堆上的对象的一个引用.
traits4

这里参考了:捋捋 Rust 中的 impl Trait 和 dyn Trait - 知乎 (zhihu.com)
由于输入的时候不能输入Box包裹,可以直接用impl Trait而不是Box.
但是返回值不能是impl Trait,因为不能返回不同类型,必须加一个包裹.

1. // traits4.rs
2. //
3. // Your task is to replace the '??' sections so the code compiles.
4. //
5. // Don't change any line other than the marked one.
6. //
7. // Execute `rustlings hint traits4` or use the `hint` watch subcommand for a
8. // hint.
10. // I AM NOT DONE
12. pub trait Licensed {
13.     fn licensing_info(&self) -> String {
14.         "some information".to_string()
15.     }
16. }
18. struct SomeSoftware {}
20. struct OtherSoftware {}
22. impl Licensed for SomeSoftware {}
23. impl Licensed for OtherSoftware {}
25. // YOU MAY ONLY CHANGE THE NEXT LINE
26. fn compare_license_types(software: impl Licensed, software_two: impl Licensed) -> bool {
27.     software.licensing_info() == software_two.licensing_info()
28. }
30. #[cfg(test)]
31. mod tests {
32.     use super::*;
34.     #[test]
35.     fn compare_license_information() {
36.         let some_software = SomeSoftware {};
37.         let other_software = OtherSoftware {};
39.         assert!(compare_license_types(some_software, other_software));
40.     }
42.     #[test]
43.     fn compare_license_information_backwards() {
44.         let some_software = SomeSoftware {};
45.         let other_software = OtherSoftware {};
47.         assert!(compare_license_types(other_software, some_software));
48.     }
49. }

复制代码

traits5

通过+选定对两个特征的要求.

1. // traits5.rs
2. //
3. // Your task is to replace the '??' sections so the code compiles.
4. //
5. // Don't change any line other than the marked one.
6. //
7. // Execute `rustlings hint traits5` or use the `hint` watch subcommand for a
8. // hint.
10. pub trait SomeTrait {
11.     fn some_function(&self) -> bool {
12.         true
13.     }
14. }
16. pub trait OtherTrait {
17.     fn other_function(&self) -> bool {
18.         true
19.     }
20. }
22. struct SomeStruct {}
23. struct OtherStruct {}
25. impl SomeTrait for SomeStruct {}
26. impl OtherTrait for SomeStruct {}
27. impl SomeTrait for OtherStruct {}
28. impl OtherTrait for OtherStruct {}
30. // YOU MAY ONLY CHANGE THE NEXT LINE
31. fn some_func(item: impl SomeTrait + OtherTrait) -> bool {
32.     item.some_function() && item.other_function()
33. }
35. fn main() {
36.     some_func(SomeStruct {});
37.     some_func(OtherStruct {});
38. }

复制代码

quiz3

这里考察的是可以给泛型的每个类型单独写方法.

1. // quiz3.rs
2. //
3. // This quiz tests:
4. // - Generics
5. // - Traits
6. //
7. // An imaginary magical school has a new report card generation system written
8. // in Rust! Currently the system only supports creating report cards where the
9. // student's grade is represented numerically (e.g. 1.0 -> 5.5). However, the
10. // school also issues alphabetical grades (A+ -> F-) and needs to be able to
11. // print both types of report card!
12. //
13. // Make the necessary code changes in the struct ReportCard and the impl block
14. // to support alphabetical report cards. Change the Grade in the second test to
15. // "A+" to show that your changes allow alphabetical grades.
16. //
17. // Execute `rustlings hint quiz3` or use the `hint` watch subcommand for a hint.
19. pub struct ReportCard<T> {
20.     pub grade: T,
21.     pub student_name: String,
22.     pub student_age: u8,
23. }
25. impl ReportCard<f32> {
26.     pub fn print(&self) -> String {
27.         format!("{} ({}) - achieved a grade of {}",
28.             &self.student_name, &self.student_age, &self.grade)
29.     }
30. }
32. impl ReportCard<&str> {
33.     pub fn print(&self) -> String {
34.         format!("{} ({}) - achieved a grade of {}",
35.             &self.student_name, &self.student_age, &self.grade)
36.     }
37. }
39. #[cfg(test)]
40. mod tests {
41.     use super::*;
43.     #[test]
44.     fn generate_numeric_report_card() {
45.         let report_card = ReportCard {
46.             grade: 2.1,
47.             student_name: "Tom Wriggle".to_string(),
48.             student_age: 12,
49.         };
50.         assert_eq!(
51.             report_card.print(),
52.             "Tom Wriggle (12) - achieved a grade of 2.1"
53.         );
54.     }
56.     #[test]
57.     fn generate_alphabetic_report_card() {
58.         // TODO: Make sure to change the grade here after you finish the exercise.
59.         let report_card = ReportCard {
60.             grade: "A+",
61.             student_name: "Gary Plotter".to_string(),
62.             student_age: 11,
63.         };
64.         assert_eq!(
65.             report_card.print(),
66.             "Gary Plotter (11) - achieved a grade of A+"
67.         );
68.     }
69. }

复制代码

lifetimes1

认识生命周期 - Rust语言圣经(Rust Course)

1. // lifetimes1.rs
2. //
3. // The Rust compiler needs to know how to check whether supplied references are
4. // valid, so that it can let the programmer know if a reference is at risk of
5. // going out of scope before it is used. Remember, references are borrows and do
6. // not own their own data. What if their owner goes out of scope?
7. //
8. // Execute `rustlings hint lifetimes1` or use the `hint` watch subcommand for a
9. // hint.
11. // I AM NOT DONE
13. fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
14.     if x.len() > y.len() {
15.         x
16.     } else {
17.         y
18.     }
19. }
21. fn main() {
22.     let string1 = String::from("abcd");
23.     let string2 = "xyz";
25.     let result = longest(string1.as_str(), string2);
26.     println!("The longest string is '{}'", result);
27. }

复制代码

tests4

这个报错过不了啊!!!!

1. // tests4.rs
2. //
3. // Make sure that we're testing for the correct conditions!
4. //
5. // Execute `rustlings hint tests4` or use the `hint` watch subcommand for a
6. // hint.
8. // I AM NOT DONE
10. struct Rectangle {
11.     width: i32,
12.     height: i32
13. }
15. impl Rectangle {
16.     // Only change the test functions themselves
17.     pub fn new(width: i32, height: i32) -> Self {
18.         if width <= 0 || height <= 0 {
19.             panic!("Rectangle width and height cannot be negative!")
20.         }
21.         Rectangle {width, height}
22.     }
23. }
25. #[cfg(test)]
26. mod tests {
27.     use super::*;
29.     #[test]
30.     fn correct_width_and_height() {
31.         // This test should check if the rectangle is the size that we pass into its constructor
32.         let rect = Rectangle::new(10, 20);
33.         assert_eq!(rect.width, 10); // check width
34.         assert_eq!(rect.height, 20); // check height
35.     }
37.     #[test]
38.     fn negative_width() {
39.         // This test should check if program panics when we try to create rectangle with negative width
40.         // let _rect = Rectangle::new(-10, 10);
41.     }
43.     #[test]
44.     fn negative_height() {
45.         // This test should check if program panics when we try to create rectangle with negative height
46.         // let _rect = Rectangle::new(10, -10);
47.     }
48. }

复制代码

iterators4

区间表达式 - Rust 参考手册 中文版 (rustwiki.org)

1. // iterators1.rs
2. //
3. // When performing operations on elements within a collection, iterators are
4. // essential. This module helps you get familiar with the structure of using an
5. // iterator and how to go through elements within an iterable collection.
6. //
7. // Make me compile by filling in the `???`s
8. //
9. // Execute `rustlings hint iterators1` or use the `hint` watch subcommand for a
10. // hint.
12. // I AM NOT DONE
14. fn main() {
15.     let my_fav_fruits = vec!["banana", "custard apple", "avocado", "peach", "raspberry"];
17.     let mut my_iterable_fav_fruits = my_fav_fruits.iter();   // TODO: Step 1
19.     assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
20.     assert_eq!(my_iterable_fav_fruits.next(), Some(&"custard apple"));     // TODO: Step 2
21.     assert_eq!(my_iterable_fav_fruits.next(), Some(&"avocado"));
22.     assert_eq!(my_iterable_fav_fruits.next(), Some(&"peach"));     // TODO: Step 3
23.     assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
24.     assert_eq!(my_iterable_fav_fruits.next(), None);     // TODO: Step 4
25. }

复制代码

iterator5

这里存在一个认知问题,就是还是存在对:

• 引用和自动解引用和*
  
• for的语法糖
  
• 借用
  

不熟悉

1. // iterators3.rs
2. //
3. // This is a bigger exercise than most of the others! You can do it! Here is
4. // your mission, should you choose to accept it:
5. // 1. Complete the divide function to get the first four tests to pass.
6. // 2. Get the remaining tests to pass by completing the result_with_list and
7. //    list_of_results functions.
8. //
9. // Execute `rustlings hint iterators3` or use the `hint` watch subcommand for a
10. // hint.
12. // I AM NOT DONE
14. #[derive(Debug, PartialEq, Eq)]
15. pub enum DivisionError {
16.     NotDivisible(NotDivisibleError),
17.     DivideByZero,
18. }
20. #[derive(Debug, PartialEq, Eq)]
21. pub struct NotDivisibleError {
22.     dividend: i32,
23.     divisor: i32,
24. }
26. // Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
27. // Otherwise, return a suitable error.
28. pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
29.     if b == 0{
30.         return Err(DivisionError::DivideByZero);
31.     }
32.     let r = a/b;
33.     if r*b==a{
34.         Ok(r)
35.     }else{
36.         Err(DivisionError::NotDivisible(NotDivisibleError{dividend:a,divisor:b}))
37.     }
38. }
40. // Complete the function and return a value of the correct type so the test
41. // passes.
42. // Desired output: Ok([1, 11, 1426, 3])
43. fn result_with_list() -> Result<Vec<i32>,DivisionError> {
44.     let numbers = vec![27, 297, 38502, 81];
45.     let division_results = numbers.into_iter().map(|n| divide(n, 27));
46.     division_results.collect::<Result<Vec<i32>, DivisionError>>()
47. }
49. // Complete the function and return a value of the correct type so the test
50. // passes.
51. // Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
52. fn list_of_results() -> Vec<Result<i32, DivisionError>> {
53.     let numbers = vec![27, 297, 38502, 81];
54.     let division_results = numbers.into_iter().map(|n| divide(n, 27));
55.     division_results.collect::<Vec<Result<i32, DivisionError>>>()
56. }
58. #[cfg(test)]
59. mod tests {
60.     use super::*;
62.     #[test]
63.     fn test_success() {
64.         assert_eq!(divide(81, 9), Ok(9));
65.     }
67.     #[test]
68.     fn test_not_divisible() {
69.         assert_eq!(
70.             divide(81, 6),
71.             Err(DivisionError::NotDivisible(NotDivisibleError {
72.                 dividend: 81,
73.                 divisor: 6
74.             }))
75.         );
76.     }
78.     #[test]
79.     fn test_divide_by_0() {
80.         assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
81.     }
83.     #[test]
84.     fn test_divide_0_by_something() {
85.         assert_eq!(divide(0, 81), Ok(0));
86.     }
88.     #[test]
89.     fn test_result_with_list() {
90.         assert_eq!(format!("{:?}", result_with_list()), "Ok([1, 11, 1426, 3])");
91.     }
93.     #[test]
94.     fn test_list_of_results() {
95.         assert_eq!(
96.             format!("{:?}", list_of_results()),
97.             "[Ok(1), Ok(11), Ok(1426), Ok(3)]"
98.         );
99.     }
100. }

复制代码

cow1

这里如果像我一样很难理解高级语言,那么我们可以去看它的实现.
这里Cow实现了两个Trait,而且是在泛型的情况下为专门的类型适配了专门的特性.
这里这两个from就引起了我的思考:

• &[T]和[T]之间有什么引用和引用的目标之间的自动转换.
  
  
  • 尤其是println!输出多层引用的时候误导了我.
    
  • Deref 解引用使得这种误导更加严重,Rust中的 实现了Deref 的类型.
    
  
  
• Cow的from是根据类型实现的泛型.
  

根据这一节所学,可以看到本来就是在讨论Cow在面对引用和引用的目标时候有不同的表现,因此应该不是自动进行了解引用:

• Cow对&[T]的from实现
  
  
  • Creates a Borrowed variant of Cow from a slice. 可以看到,是创建了一个Borrowed.
    
  
  
• Cow对Vec的实现
  
  
  • Creates an Owned variant of Cow from an owned instance of Vec. 可以看到是创建了一个Owned.
    
  
  

这里看源码看了半天找不到的原因是没有弄明白&[T],[T],Vec,vec!的区别.

• 首先[T]是数组Vec是可变数组,是不同的.
  
• &[T]是一个数组的引用.
  
• vec!是一个宏,返回的是Vec.
  

这里必须提到,Cow没有实现对于[T]的from,所以其中使用的是vec!返回的Vec.
例子中,一会使用&[T]一会使用Vec给了我非常大的误导
这里还有一个遗漏的点,数组切片.

let mut input = Cow::from(&slice[..]); 这一句用的就是数组切片.

1. // iterators4.rs
2. //
3. // Execute `rustlings hint iterators4` or use the `hint` watch subcommand for a
4. // hint.
6. // I AM NOT DONE
8. pub fn factorial(num: u64) -> u64 {
9.     // Complete this function to return the factorial of num
10.     // Do not use:
11.     // - return
12.     // Try not to use:
13.     // - imperative style loops (for, while)
14.     // - additional variables
15.     // For an extra challenge, don't use:
16.     // - recursion
17.     // Execute `rustlings hint iterators4` for hints.
18.     (1..=num).product()
19. }
21. #[cfg(test)]
22. mod tests {
23.     use super::*;
25.     #[test]
26.     fn factorial_of_0() {
27.         assert_eq!(1, factorial(0));
28.     }
30.     #[test]
31.     fn factorial_of_1() {
32.         assert_eq!(1, factorial(1));
33.     }
34.     #[test]
35.     fn factorial_of_2() {
36.         assert_eq!(2, factorial(2));
37.     }
39.     #[test]
40.     fn factorial_of_4() {
41.         assert_eq!(24, factorial(4));
42.     }
43. }

复制代码

threads1

如果大家学过其它语言的多线程，可能就知道不同语言对于线程的实现可能大相径庭：

• 由于操作系统提供了创建线程的 API，因此部分语言会直接调用该 API 来创建线程，因此最终程序内的线程数和该程序占用的操作系统线程数相等，一般称之为1:1 线程模型，例如 Rust。
  
• 还有些语言在内部实现了自己的线程模型（绿色线程、协程），程序内部的 M 个线程最后会以某种映射方式使用 N 个操作系统线程去运行，因此称之为M:N 线程模型，其中 M 和 N 并没有特定的彼此限制关系。一个典型的代表就是 Go 语言。
  
• 还有些语言使用了 Actor 模型，基于消息传递进行并发，例如 Erlang 语言。
  

总之，每一种模型都有其优缺点及选择上的权衡，而 Rust 在设计时考虑的权衡就是运行时(Runtime)。出于 Rust 的系统级使用场景，且要保证调用 C 时的极致性能，它最终选择了尽量小的运行时实现。
有时候只看一本书是不够的,还需要多看几本书.

1. // iterators5.rs
2. //
3. // Let's define a simple model to track Rustlings exercise progress. Progress
4. // will be modelled using a hash map. The name of the exercise is the key and
5. // the progress is the value. Two counting functions were created to count the
6. // number of exercises with a given progress. Recreate this counting
7. // functionality using iterators. Try not to use imperative loops (for, while).
8. // Only the two iterator methods (count_iterator and count_collection_iterator)
9. // need to be modified.
10. //
11. // Execute `rustlings hint iterators5` or use the `hint` watch subcommand for a
12. // hint.
14. // I AM NOT DONE
16. use std::collections::HashMap;
18. #[derive(Clone, Copy, PartialEq, Eq)]
19. enum Progress {
20.     None,
21.     Some,
22.     Complete,
23. }
25. fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
26.     let mut count = 0;
27.     for val in map.values() {
28.         if val == &value {
29.             count += 1;
30.         }
31.     }
32.     count
33. }
35. fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
36.     // map is a hashmap with String keys and Progress values.
37.     // map = { "variables1": Complete, "from_str": None, ... }
38.     map.values().filter(|v| *v==&value).count()
39. }
41. fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
42.     let mut count = 0;
43.     for map in collection {
44.         for val in map.values() {
45.             if val == &value {
46.                 count += 1;
47.             }
48.         }
49.     }
50.     count
51. }
53. fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
54.     // collection is a slice of hashmaps.
55.     // collection = [{ "variables1": Complete, "from_str": None, ... },
56.     //     { "variables2": Complete, ... }, ... ]
57.     collection.into_iter().map(|c| count_iterator(c,value)).sum()
58. }
60. #[cfg(test)]
61. mod tests {
62.     use super::*;
64.     #[test]
65.     fn count_complete() {
66.         let map = get_map();
67.         assert_eq!(3, count_iterator(&map, Progress::Complete));
68.     }
70.     #[test]
71.     fn count_some() {
72.         let map = get_map();
73.         assert_eq!(1, count_iterator(&map, Progress::Some));
74.     }
76.     #[test]
77.     fn count_none() {
78.         let map = get_map();
79.         assert_eq!(2, count_iterator(&map, Progress::None));
80.     }
82.     #[test]
83.     fn count_complete_equals_for() {
84.         let map = get_map();
85.         let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
86.         for progress_state in progress_states {
87.             assert_eq!(
88.                 count_for(&map, progress_state),
89.                 count_iterator(&map, progress_state)
90.             );
91.         }
92.     }
94.     #[test]
95.     fn count_collection_complete() {
96.         let collection = get_vec_map();
97.         assert_eq!(
98.             6,
99.             count_collection_iterator(&collection, Progress::Complete)
100.         );
101.     }
103.     #[test]
104.     fn count_collection_some() {
105.         let collection = get_vec_map();
106.         assert_eq!(1, count_collection_iterator(&collection, Progress::Some));
107.     }
109.     #[test]
110.     fn count_collection_none() {
111.         let collection = get_vec_map();
112.         assert_eq!(4, count_collection_iterator(&collection, Progress::None));
113.     }
115.     #[test]
116.     fn count_collection_equals_for() {
117.         let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
118.         let collection = get_vec_map();
120.         for progress_state in progress_states {
121.             assert_eq!(
122.                 count_collection_for(&collection, progress_state),
123.                 count_collection_iterator(&collection, progress_state)
124.             );
125.         }
126.     }
128.     fn get_map() -> HashMap<String, Progress> {
129.         use Progress::*;
131.         let mut map = HashMap::new();
132.         map.insert(String::from("variables1"), Complete);
133.         map.insert(String::from("functions1"), Complete);
134.         map.insert(String::from("hashmap1"), Complete);
135.         map.insert(String::from("arc1"), Some);
136.         map.insert(String::from("as_ref_mut"), None);
137.         map.insert(String::from("from_str"), None);
139.         map
140.     }
142.     fn get_vec_map() -> Vec<HashMap<String, Progress>> {
143.         use Progress::*;
145.         let map = get_map();
147.         let mut other = HashMap::new();
148.         other.insert(String::from("variables2"), Complete);
149.         other.insert(String::from("functions2"), Complete);
150.         other.insert(String::from("if1"), Complete);
151.         other.insert(String::from("from_into"), None);
152.         other.insert(String::from("try_from_into"), None);
154.         vec![map, other]
155.     }
156. }

复制代码

thread2

告诉我们一个道理join只是检测线程有没有运行,不一定是你join的时候它才运行的.
另外就是用好互斥锁Mutex和RefCell:

• RefCell是一个纯在单线程环境中的可变,可以配合Rc完成单线程中共享变量的安全,并且可以修改其中成员的值.
  
• Mutex是我们熟悉的互斥锁,支持多线程,和Arc可以配合好
  

1. // cow1.rs
2. //
3. // This exercise explores the Cow, or Clone-On-Write type. Cow is a
4. // clone-on-write smart pointer. It can enclose and provide immutable access to
5. // borrowed data, and clone the data lazily when mutation or ownership is
6. // required. The type is designed to work with general borrowed data via the
7. // Borrow trait.
8. //
9. // This exercise is meant to show you what to expect when passing data to Cow.
10. // Fix the unit tests by checking for Cow::Owned(_) and Cow::Borrowed(_) at the
11. // TODO markers.
12. //
13. // Execute `rustlings hint cow1` or use the `hint` watch subcommand for a hint.
15. // I AM NOT DONE
17. use std::borrow::Cow;
19. fn abs_all<'a, 'b>(input: &'a mut Cow<'b, [i32]>) -> &'a mut Cow<'b, [i32]> {
20.     for i in 0..input.len() {
21.         let v = input[i];
22.         if v < 0 {
23.             // Clones into a vector if not already owned.
24.             input.to_mut()[i] = -v;
25.         }
26.     }
27.     input
28. }
30. #[cfg(test)]
31. mod tests {
32.     use super::*;
34.     #[test]
35.     fn reference_mutation() -> Result<(), &'static str> {
36.         // Clone occurs because `input` needs to be mutated.
37.         let slice = [-1, 0, 1];
38.         let mut input = Cow::from(&slice[..]);
39.         match abs_all(&mut input) {
40.             Cow::Owned(_) => Ok(()),
41.             _ => Err("Expected owned value"),
42.         }
43.     }
45.     #[test]
46.     fn reference_no_mutation() -> Result<(), &'static str> {
47.         // No clone occurs because `input` doesn't need to be mutated.
48.         let slice = [0, 1, 2];
49.         let mut input = Cow::from(&slice[..]);
50.         match abs_all(&mut input) {
51.             Cow::Borrowed(_) => Ok(()),
52.             _ => Err("Expected owned value"),
53.         }
54.     }
56.     #[test]
57.     fn owned_no_mutation() -> Result<(), &'static str> {
58.         // We can also pass `slice` without `&` so Cow owns it directly. In this
59.         // case no mutation occurs and thus also no clone, but the result is
60.         // still owned because it was never borrowed or mutated.
61.         let slice = vec![0, 1, 2];
62.         let mut input = Cow::from(slice);
63.         match abs_all(&mut input) {
64.             Cow::Owned(_) => Ok(()),
65.             _ => Err("Expected owned value"),
66.         }
67.     }
69.     #[test]
70.     fn owned_mutation() -> Result<(), &'static str> {
71.         // Of course this is also the case if a mutation does occur. In this
72.         // case the call to `to_mut()` returns a reference to the same data as
73.         // before.
74.         let slice = vec![-1, 0, 1];
75.         let mut input = Cow::from(slice);
76.         match abs_all(&mut input) {
77.             Cow::Owned(_) => Ok(()),
78.             _ => Err("Expected owned value"),
79.         }
80.     }
81. }

复制代码

log

1. // threads1.rs
2. //
3. // This program spawns multiple threads that each run for at least 250ms, and
4. // each thread returns how much time they took to complete. The program should
5. // wait until all the spawned threads have finished and should collect their
6. // return values into a vector.
7. //
8. // Execute `rustlings hint threads1` or use the `hint` watch subcommand for a
9. // hint.
11. use std::thread;
12. use std::time::{Duration, Instant};
14. fn main() {
15.     let mut handles = vec![];
16.     for i in 0..10 {
17.         handles.push(thread::spawn(move || {
18.             let start = Instant::now();
19.             thread::sleep(Duration::from_millis(250));
20.             println!("thread {} is complete", i);
21.             start.elapsed().as_millis()
22.         }));
23.     }
25.     let mut results: Vec<u128> = vec![];
26.     for handle in handles {
27.         // TODO: a struct is returned from thread::spawn, can you use it?
28.         results.push({
29.             match handle.join(){
30.                 Ok(t) => t,
31.                 Err(_) => panic!("Some thing wrong!!!")
32.             }
33.         })
34.     }
36.     if results.len() != 10 {
37.         panic!("Oh no! All the spawned threads did not finish!");
38.     }
40.     println!();
41.     for (i, result) in results.into_iter().enumerate() {
42.         println!("thread {} took {}ms", i, result);
43.     }
44. }

复制代码

from_str

好的逻辑是计划出来的是想出来的,不是混出来的,不是尝试出来的,如果这也要以做出来为标准,那么你学了什么呢?

1. // threads2.rs
2. //
3. // Building on the last exercise, we want all of the threads to complete their
4. // work but this time the spawned threads need to be in charge of updating a
5. // shared value: JobStatus.jobs_completed
6. //
7. // Execute `rustlings hint threads2` or use the `hint` watch subcommand for a
8. // hint.
10. // I AM NOT DONE
12. use std::sync::{Arc,Mutex};
13. use std::thread;
14. use std::time::Duration;
16. struct JobStatus {
17.     jobs_completed: u32,
18. }
20. fn main() {
21.     let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
22.     let mut handles = vec![];
23.     for _ in 0..10 {
24.         let status_shared = Arc::clone(&status);
25.         let handle = thread::spawn(move || {
26.             thread::sleep(Duration::from_millis(250));
27.             // TODO: You must take an action before you update a shared value
28.             let mut status_shared  = match status_shared.lock()
29.             {
30.                 Ok(status) => status,
31.                 Err(_) => panic!("Error")  
32.             };
33.             status_shared.jobs_completed += 1;
34.         });
35.         handles.push(handle);
36.     }
37.     for handle in handles {
38.         handle.join().unwrap();
39.         // TODO: Print the value of the JobStatus.jobs_completed. Did you notice
40.         // anything interesting in the output? Do you have to 'join' on all the
41.         // handles?
42.         let status = status.lock().unwrap();
43.         println!("jobs completed {}", status.jobs_completed);
44.     }
45. }

复制代码

algorithm4


使用 value.cmp 可以防止 T 不支持>, Self {        TreeNode {            value,            left: None,            right: None,        }    }}impl BinarySearchTreewhere    T: Ord,{    fn new() -> Self {        BinarySearchTree { root: None }    }    // Insert a value into the BST    fn insert(&mut self, value: T) {        //TODO        let mut current = &mut self.root;        while let Some(ref mut node) = current {            if value < node.value {                current = &mut node.left;            } else if value > node.value {                current = &mut node.right;            } else {                return;            }        }        *current = Some(Box::new(TreeNode::new(value)));    }    // Search for a value in the BST    fn search(&self, value: T) -> bool {        let mut current = &self.root;        while let Some(node) = current {            match value.cmp(&node.value) {                Ordering:ess => current = &node.left,                Ordering::Greater => current = &node.right,                Ordering::Equal => return true,            }        }        false    }}impl TreeNodewhere    T: Ord,{    // Insert a node into the tree    fn insert(&mut self, value: T) {        if value  panic!("There is all ready a node left"),                None => self.left = Some(Box::new(TreeNode::::new(value))),            };        }else{            match self.right{                Some(_) => panic!("There is all ready a node right"),                None => self.right = Some(Box::new(TreeNode::::new(value))),            }        }    }    fn is_full(self) -> bool{        (!self.left.is_none()) && (!self.right.is_none())    }}#[cfg(test)]mod tests {    use super::*;    #[test]    fn test_insert_and_search() {        let mut bst = BinarySearchTree::new();                assert_eq!(bst.search(1), false);                bst.insert(5);        bst.insert(3);        bst.insert(7);        bst.insert(2);        bst.insert(4);                assert_eq!(bst.search(5), true);        assert_eq!(bst.search(3), true);        assert_eq!(bst.search(7), true);        assert_eq!(bst.search(2), true);        assert_eq!(bst.search(4), true);                assert_eq!(bst.search(1), false);        assert_eq!(bst.search(6), false);    }    #[test]    fn test_insert_duplicate() {        let mut bst = BinarySearchTree::new();                bst.insert(1);        bst.insert(1);                assert_eq!(bst.search(1), true);                match bst.root {            Some(ref node) => {                assert!(node.left.is_none());                assert!(node.right.is_none());            },            None => panic!("Root should not be None after insertion"),        }    }}    [/code]algorithm6

无比丑陋的DFS.
#TODO 写点好看的吧.

1. Output:
2. ====================
3. jobs completed 6
4. jobs completed 6
5. jobs completed 6
6. jobs completed 7
7. jobs completed 7
8. jobs completed 7
9. jobs completed 10
10. jobs completed 10
11. jobs completed 10
12. jobs completed 10
14. ====================

复制代码

不写递归的后果:

GPT写的,多么的聪明

1. // from_str.rs
2. //
3. // This is similar to from_into.rs, but this time we'll implement `FromStr` and
4. // return errors instead of falling back to a default value. Additionally, upon
5. // implementing FromStr, you can use the `parse` method on strings to generate
6. // an object of the implementor type. You can read more about it at
7. // https://doc.rust-lang.org/std/str/trait.FromStr.html
8. //
9. // Execute `rustlings hint from_str` or use the `hint` watch subcommand for a
10. // hint.
12. use std::num::ParseIntError;
13. use std::str::FromStr;
15. #[derive(Debug, PartialEq)]
16. struct Person {
17.     name: String,
18.     age: usize,
19. }
21. // We will use this error type for the `FromStr` implementation.
22. #[derive(Debug, PartialEq)]
23. enum ParsePersonError {
24.     // Empty input string
25.     Empty,
26.     // Incorrect number of fields
27.     BadLen,
28.     // Empty name field
29.     NoName,
30.     // Wrapped error from parse::<usize>()
31.     ParseInt(ParseIntError),
32. }
34. // I AM NOT DONE
36. // Steps:
37. // 1. If the length of the provided string is 0, an error should be returned
38. // 2. Split the given string on the commas present in it
39. // 3. Only 2 elements should be returned from the split, otherwise return an
40. //    error
41. // 4. Extract the first element from the split operation and use it as the name
42. // 5. Extract the other element from the split operation and parse it into a
43. //    `usize` as the age with something like `"4".parse::<usize>()`
44. // 6. If while extracting the name and the age something goes wrong, an error
45. //    should be returned
46. // If everything goes well, then return a Result of a Person object
47. //
48. // As an aside: `Box<dyn Error>` implements `From<&'_ str>`. This means that if
49. // you want to return a string error message, you can do so via just using
50. // return `Err("my error message".into())`.
52. impl FromStr for Person {
53.     type Err = ParsePersonError;
54.     fn from_str(s: &str) -> Result<Person, Self::Err> {
55.         if s.is_empty() {
56.             return Err(ParsePersonError::Empty);
57.         }
58.         let v:Vec<_> = s.split(",").collect();
59.         if v.len() != 2{
60.             return Err(ParsePersonError::BadLen);
61.         }
62.         let name = {
63.             if v[0].is_empty(){
64.                 return Err(ParsePersonError::NoName);
65.             }
66.             v[0].to_string()
67.         };
68.         let age = match v[1].parse::<usize>(){
69.             Ok(age) => age,
70.             Err(err) => return Err(ParsePersonError::ParseInt(err))
71.         };
72.         Ok(Person{
73.             name: name,
74.             age: age,
75.         })
76.     }
77. }
79. fn main() {
80.     let p = "Mark,20".parse::<Person>().unwrap();
81.     println!("{:?}", p);
82. }
84. #[cfg(test)]
85. mod tests {
86.     use super::*;
88.     #[test]
89.     fn empty_input() {
90.         assert_eq!("".parse::<Person>(), Err(ParsePersonError::Empty));
91.     }
92.     #[test]
93.     fn good_input() {
94.         let p = "John,32".parse::<Person>();
95.         assert!(p.is_ok());
96.         let p = p.unwrap();
97.         assert_eq!(p.name, "John");
98.         assert_eq!(p.age, 32);
99.     }
100.     #[test]
101.     fn missing_age() {
102.         assert!(matches!(
103.             "John,".parse::<Person>(),
104.             Err(ParsePersonError::ParseInt(_))
105.         ));
106.     }
108.     #[test]
109.     fn invalid_age() {
110.         assert!(matches!(
111.             "John,twenty".parse::<Person>(),
112.             Err(ParsePersonError::ParseInt(_))
113.         ));
114.     }
116.     #[test]
117.     fn missing_comma_and_age() {
118.         assert_eq!("John".parse::<Person>(), Err(ParsePersonError::BadLen));
119.     }
121.     #[test]
122.     fn missing_name() {
123.         assert_eq!(",1".parse::<Person>(), Err(ParsePersonError::NoName));
124.     }
126.     #[test]
127.     fn missing_name_and_age() {
128.         assert!(matches!(
129.             ",".parse::<Person>(),
130.             Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
131.         ));
132.     }
134.     #[test]
135.     fn missing_name_and_invalid_age() {
136.         assert!(matches!(
137.             ",one".parse::<Person>(),
138.             Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
139.         ));
140.     }
142.     #[test]
143.     fn trailing_comma() {
144.         assert_eq!("John,32,".parse::<Person>(), Err(ParsePersonError::BadLen));
145.     }
147.     #[test]
148.     fn trailing_comma_and_some_string() {
149.         assert_eq!(
150.             "John,32,man".parse::<Person>(),
151.             Err(ParsePersonError::BadLen)
152.         );
153.     }
154. }

复制代码

algorithm8

这里出现一个借用性问题: #TODO

1. //! This is the build script for both tests7 and tests8.
2. //!
3. //! You should modify this file to make both exercises pass.
6. fn main() {
7.     // In tests7, we should set up an environment variable
8.     // called `TEST_FOO`. Print in the standard output to let
9.     // Cargo do it.
10.     let timestamp = std::time::SystemTime::now()
11.         .duration_since(std::time::UNIX_EPOCH)
12.         .unwrap()
13.         .as_secs(); // What's the use of this timestamp here?
14.     let your_command = format!(
15.         "rustc-env=TEST_FOO={}",
16.         timestamp.to_string()
17.     );
18.     println!("cargo:{}", your_command);
20.     // In tests8, we should enable "pass" feature to make the
21.     // testcase return early. Fill in the command to tell
22.     // Cargo about that.
23.     // let your_command = "Your command here, please checkout exercises/tests/build.rs";
24.     // println!("cargo:{}", your_command);
25. }

复制代码

不能被改成:
`

1. // tests9.rs
2. //
3. // Rust is highly capable of sharing FFI interfaces with C/C++ and other statically compiled
4. // languages, and it can even link within the code itself! It makes it through the extern
5. // block, just like the code below.
6. //
7. // The short string after the `extern` keyword indicates which ABI the externally imported
8. // function would follow. In this exercise, "Rust" is used, while other variants exists like
9. // "C" for standard C ABI, "stdcall" for the Windows ABI.
10. //
11. // The externally imported functions are declared in the extern blocks, with a semicolon to
12. // mark the end of signature instead of curly braces. Some attributes can be applied to those
13. // function declarations to modify the linking behavior, such as #[link_name = ".."] to
14. // modify the actual symbol names.
15. //
16. // If you want to export your symbol to the linking environment, the `extern` keyword can
17. // also be marked before a function definition with the same ABI string note. The default ABI
18. // for Rust functions is literally "Rust", so if you want to link against pure Rust functions,
19. // the whole extern term can be omitted.
20. //
21. // Rust mangles symbols by default, just like C++ does. To suppress this behavior and make
22. // those functions addressable by name, the attribute #[no_mangle] can be applied.
23. //
24. // In this exercise, your task is to make the testcase able to call the `my_demo_function` in
25. // module Foo. the `my_demo_function_alias` is an alias for `my_demo_function`, so the two
26. // line of code in the testcase should call the same function.
27. //
28. // You should NOT modify any existing code except for adding two lines of attributes.
30. // I AM NOT DONE
32. extern "Rust" {
33.     #[no_mangle]
34.     fn my_demo_function(a: u32) -> u32;
35.     #[no_mangle]
36.     #[link_name = "my_demo_function"]
37.     fn my_demo_function_alias(a: u32) -> u32;
38. }
40. mod Foo {
41.     // No `extern` equals `extern "Rust"`.
42.     #[no_mangle]
43.     fn my_demo_function(a: u32) -> u32 {
44.         a
45.     }
46. }
48. #[cfg(test)]
49. mod tests {
50.     use super::*;
52.     #[test]
53.     fn test_success() {
54.         // The externally imported functions are UNSAFE by default
55.         // because of untrusted source of other languages. You may
56.         // wrap them in safe Rust APIs to ease the burden of callers.
57.         //
58.         // SAFETY: We know those functions are aliases of a safe
59.         // Rust function.
60.         unsafe {
61.             my_demo_function(123);
62.             my_demo_function_alias(456);
63.         }
64.     }
65. }

复制代码

1. /*        queue        This question requires you to use queues to implement the functionality of the stac*/// I AM NOT DONE#[derive(Debug)]pub struct Queue {    elements: Vec,}impl Queue {    pub fn new() -> Queue {        Queue {            elements: Vec::new(),        }    }    pub fn enqueue(&mut self, value: T) {        self.elements.push(value)    }    pub fn dequeue(&mut self) -> Result {        if !self.elements.is_empty() {            Ok(self.elements.remove(0usize))        } else {            Err("Queue is empty")        }    }    pub fn peek(&self) -> Result {        match self.elements.first() {            Some(value) => Ok(value),            None => Err("Queue is empty"),        }    }    pub fn size(&self) -> usize {        self.elements.len()    }    pub fn is_empty(&self) -> bool {        self.elements.is_empty()    }}impl Default for Queue {    fn default() -> Queue {        Queue {            elements: Vec::new(),        }    }}enum SelectedQueue{    Q1,    Q2,}pub struct myStack{        //TODO    flag: SelectedQueue,        q1:Queue,        q2:Queue}impl myStack {    pub fn new() -> Self {        Self {                        //TODO            flag: SelectedQueue::Q1,                        q1:Queue::::new(),                        q2:Queue::::new()        }    }    pub fn push(&mut self, elem: T) {        //TODO        let q = match self.flag{            SelectedQueue::Q1 => &mut self.q1,            SelectedQueue::Q2 => &mut self.q2,        };        q.enqueue(elem);    }    pub fn pop(& mut self) -> Result {        //TODO        let (q1,q2) = match self.flag{            SelectedQueue::Q1 => (&mut self.q1,&mut self.q2),            SelectedQueue::Q2 => (&mut self.q2,&mut self.q1),        };        if q1.is_empty(){            return Err("Stack is empty");        }//! This is the build script for both tests7 and tests8.
2. //!
3. //! You should modify this file to make both exercises pass.
6. fn main() {
7.     // In tests7, we should set up an environment variable
8.     // called `TEST_FOO`. Print in the standard output to let
9.     // Cargo do it.
10.     let timestamp = std::time::SystemTime::now()
11.         .duration_since(std::time::UNIX_EPOCH)
12.         .unwrap()
13.         .as_secs(); // What's the use of this timestamp here?
14.     let your_command = format!(
15.         "rustc-env=TEST_FOO={}",
16.         timestamp.to_string()
17.     );
18.     println!("cargo:{}", your_command);
20.     // In tests8, we should enable "pass" feature to make the
21.     // testcase return early. Fill in the command to tell
22.     // Cargo about that.
23.     // let your_command = "Your command here, please checkout exercises/tests/build.rs";
24.     // println!("cargo:{}", your_command);
25. }        self.flag = match self.flag {            SelectedQueue::Q1 => SelectedQueue::Q2,            SelectedQueue::Q2 => SelectedQueue::Q1,        };        Ok(elem)    }    pub fn is_empty(&self) -> bool {                //TODO        match self.flag{            SelectedQueue::Q1 => self.q1.is_empty(),            SelectedQueue::Q2 => self.q2.is_empty(),        }    }}#[cfg(test)]mod tests {        use super::*;                #[test]        fn test_queue(){                let mut s = myStack::::new();                assert_eq!(s.pop(), Err("Stack is empty"));        s.push(1);        s.push(2);        s.push(3);        assert_eq!(s.pop(), Ok(3));        assert_eq!(s.pop(), Ok(2));        s.push(4);        s.push(5);        assert_eq!(s.is_empty(), false);        assert_eq!(s.pop(), Ok(5));        assert_eq!(s.pop(), Ok(4));        assert_eq!(s.pop(), Ok(1));        assert_eq!(s.pop(), Err("Stack is empty"));        assert_eq!(s.is_empty(), true);        }}

复制代码

algorithm9

堆的维护,一如既往地尿流到哪,沟就挖到哪.
数据结构堆(Heap)详解-堆的建立、插入、删除、最大堆、最小堆、堆排序等_最大堆 heap 是一个什么样的存在?-CSDN博客

1. /*
2.         dfs
3.         This problem requires you to implement a basic DFS traversal
4. */
6. // I AM NOT DONE
7. use std::collections::HashSet;
8. use std::collections::VecDeque;
10. struct Graph {
11.     adj: Vec<Vec<usize>>,
12. }
14. impl Graph {
15.     fn new(n: usize) -> Self {
16.         Graph {
17.             adj: vec![vec![]; n],
18.         }
19.     }
21.     fn add_edge(&mut self, src: usize, dest: usize) {
22.         self.adj[src].push(dest);
23.         self.adj[dest].push(src);
24.     }
26.     fn dfs_util(&self, v: usize, visited: &mut HashSet<usize>, visit_order: &mut Vec<usize>) {
27.         //TODO
28.         let mut cur = v;  // 当前指向的指针
29.         visit_order.push(cur);
30.         visited.insert(cur);
31.         loop{
32.             let mut cnt = 0;
33.             for i in &self.adj[cur]{
34.                 if !visited.contains(i){
35.                     visit_order.push(*i);
36.                     visited.insert(*i);
37.                     cur = *i;
38.                     break;
39.                 }
40.                 cnt+=1;
41.             }
42.             if cnt>=self.adj[cur].len(){
43.                 if cur==v{
44.                     break;
45.                 }
46.                 for i in (0..visit_order.len()).rev(){
47.                     cur = visit_order[i];
48.                 }
49.             }
50.         }
51.     }
53.     // Perform a depth-first search on the graph, return the order of visited nodes
54.     fn dfs(&self, start: usize) -> Vec<usize> {
55.         let mut visited = HashSet::new();
56.         let mut visit_order = Vec::new();
57.         self.dfs_util(start, &mut visited, &mut visit_order);
58.         visit_order
59.     }
60. }
62. #[cfg(test)]
63. mod tests {
64.     use super::*;
66.     #[test]
67.     fn test_dfs_simple() {
68.         let mut graph = Graph::new(3);
69.         graph.add_edge(0, 1);
70.         graph.add_edge(1, 2);
72.         let visit_order = graph.dfs(0);
73.         assert_eq!(visit_order, vec![0, 1, 2]);
74.     }
76.     #[test]
77.     fn test_dfs_with_cycle() {
78.         let mut graph = Graph::new(4);
79.         graph.add_edge(0, 1);
80.         graph.add_edge(0, 2);
81.         graph.add_edge(1, 2);
82.         graph.add_edge(2, 3);
83.         graph.add_edge(3, 3);
85.         let visit_order = graph.dfs(0);
86.         assert_eq!(visit_order, vec![0, 1, 2, 3]);
87.     }
89.     #[test]
90.     fn test_dfs_disconnected_graph() {
91.         let mut graph = Graph::new(5);
92.         graph.add_edge(0, 1);
93.         graph.add_edge(0, 2);
94.         graph.add_edge(3, 4);
96.         let visit_order = graph.dfs(0);
97.         assert_eq!(visit_order, vec![0, 1, 2]);
98.         let visit_order_disconnected = graph.dfs(3);
99.         assert_eq!(visit_order_disconnected, vec![3, 4]);
100.     }
101. }

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！