From d989bbebd0f1d46529c341afff2239bac68e041d Mon Sep 17 00:00:00 2001
From: Constantin Berhard <git.mail.enormator@xoxy.net>
Date: Thu, 14 Apr 2016 12:16:04 +0200
Subject: [PATCH 1/2] added exercise iterator1 and its solution
---
standard_library_types/iterator1.rs | 128 +++++++++++++++++++
standard_library_types/iterator1_solution.rs | 68 ++++++++++
2 files changed, 196 insertions(+)
create mode 100644 standard_library_types/iterator1.rs
create mode 100644 standard_library_types/iterator1_solution.rs
diff --git a/standard_library_types/iterator1.rs b/standard_library_types/iterator1.rs
new file mode 100644
index 0000000..fb3f268
--- /dev/null
+++ b/standard_library_types/iterator1.rs
@@ -0,0 +1,128 @@
+// 1. Complete the divide function
+// 2. Uncomment and complete the second part of the main function
+// For part 2 there is a minor hint around line 100 and a major hint around line 128
+// There is a minor side quest in the "print_result_with_list" function
+// Have fun :-)
+
+// In production code you would not derive Debug, but implement it manually to get a better error message.
+#[derive(Debug,PartialEq,Eq)]
+enum DivisionError {
+ NotDivisible(NotDivisibleError),
+ DivideByZero,
+}
+#[derive(Debug,PartialEq,Eq)]
+struct NotDivisibleError {
+ divident: i32,
+ divisor: i32,
+}
+
+// This function calculates a/b if a is divisible by b.
+// Otherwise it returns a suitable error.
+fn divide(a: i32, b: i32) -> Result<i32,DivisionError> {
+ if b == 0 {
+
+ }
+ match a % b {
+
+ }
+}
+
+// these print functions exist, so you have to satisfy their input types in the main function
+fn print_list_of_results(l: Vec<Result<i32,DivisionError>>) {
+ println!("{:?}", l);
+}
+fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
+ // side quest: why is there no semicolon in this function?
+ match r {
+ Ok(v) => println!("All numbers were successfully divided: {:?}", v),
+ Err(e) => match e {
+ DivisionError::NotDivisible(nde) => println!("Failed to divide {} by {}: Not divisible!", nde.divident, nde.divisor),
+ DivisionError::DivideByZero => println!("Can't divide by zero"),
+ },
+ };
+}
+
+#[allow(dead_code)]
+enum OperationMode {
+ ListOfResults,
+ ResultWithList,
+}
+
+fn main() {
+ // These asserts check that your `divide` function works.
+ // In production code these would be tests
+ assert_eq!(divide(81,9),Ok(9));
+ assert_eq!(divide(81,6),Err(DivisionError::NotDivisible(NotDivisibleError{divident:81,divisor:6})));
+ assert_eq!(divide(81,0),Err(DivisionError::DivideByZero));
+ println!("Your divide function seems to work! Good Job.");
+
+ /* Second part of main. Uncomment to continue.
+ let numbers = vec![27,297,38502,81];
+
+ let division_results = // Do not convert the results into a Vec yet. Leave them iterable for now.
+ let operation_mode = OperationMode::ResultWithList;
+ match operation_mode {
+ OperationMode::ResultWithList => {
+
+ print_result_with_list(x);
+ },
+ OperationMode::ListOfResults => {
+
+ print_list_of_results(x);
+ },
+ } */
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Minor hint: In each of the two cases in the match in main, you can create x with either a 'turbofish' or by hinting the type of x to the compiler. You may try both.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Major hint: Have a look at the Iter trait and at the explanation of its collect function. Especially the part about Result is interesting.
diff --git a/standard_library_types/iterator1_solution.rs b/standard_library_types/iterator1_solution.rs
new file mode 100644
index 0000000..daca1e4
--- /dev/null
+++ b/standard_library_types/iterator1_solution.rs
@@ -0,0 +1,68 @@
+
+// In production code you would not derive Debug, but implement it manually to get a better error message.
+#[derive(Debug,PartialEq,Eq)]
+enum DivisionError {
+ NotDivisible(NotDivisibleError),
+ DivideByZero,
+}
+#[derive(Debug,PartialEq,Eq)]
+struct NotDivisibleError {
+ divident: i32,
+ divisor: i32,
+}
+
+// This function calculates a/b if a is divisible by b.
+// Otherwise it returns a suitable error.
+fn divide(a: i32, b: i32) -> Result<i32,DivisionError> {
+ if b == 0 {
+ return Err(DivisionError::DivideByZero);
+ }
+ match a % b {
+ 0 => Ok(a/b),
+ _ => Err(DivisionError::NotDivisible(NotDivisibleError{divident:a, divisor:b})),
+ }
+}
+
+// these print functions exist, so you have to satisfy their input types in the main function
+fn print_list_of_results(l: Vec<Result<i32,DivisionError>>) {
+ println!("{:?}", l);
+}
+fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
+ // side quest: why is there no semicolon in this function?
+ match r {
+ Ok(v) => println!("All numbers were successfully divided: {:?}", v),
+ Err(e) => match e {
+ DivisionError::NotDivisible(nde) => println!("Failed to divide {} by {}: Not divisible!", nde.divident, nde.divisor),
+ DivisionError::DivideByZero => println!("Can't divide by zero"),
+ },
+ };
+}
+
+#[allow(dead_code)]
+enum OperationMode {
+ ListOfResults,
+ ResultWithList,
+}
+
+fn main() {
+ // These asserts check that your `divide` function works.
+ // In production code these would be tests
+ assert_eq!(divide(81,9),Ok(9));
+ assert_eq!(divide(81,6),Err(DivisionError::NotDivisible(NotDivisibleError{divident:81,divisor:6})));
+ assert_eq!(divide(81,0),Err(DivisionError::DivideByZero));
+ println!("Your divide function seems to work! Good Job.");
+ let numbers = vec![27,297,38502,81];
+ let numbers_iterator = numbers.into_iter();
+ let division_results = numbers_iterator.map(|n| divide(n, 27));
+ let operation_mode = OperationMode::ResultWithList; // you may change this
+ match operation_mode {
+ OperationMode::ResultWithList => {
+ let x : Result<Vec<_>,_> = division_results.collect();
+ print_result_with_list(x);
+ },
+ OperationMode::ListOfResults => {
+ let x : Vec<_> = division_results.collect();
+ print_list_of_results(x);
+ },
+ }
+}
From 78014c0a73eafc44cbe125addd598df1828973e0 Mon Sep 17 00:00:00 2001
From: Constantin Berhard <git.mail.enormator@xoxy.net>
Date: Thu, 14 Apr 2016 12:48:18 +0200
Subject: [PATCH 2/2] fixed iterator1 exercise by giving the compiler less
clues
---
standard_library_types/iterator1.rs | 90 ++++++++++++++------
standard_library_types/iterator1_solution.rs | 22 ++---
2 files changed, 74 insertions(+), 38 deletions(-)
diff --git a/standard_library_types/iterator1.rs b/standard_library_types/iterator1.rs
index fb3f268..b29faa4 100644
--- a/standard_library_types/iterator1.rs
+++ b/standard_library_types/iterator1.rs
@@ -1,9 +1,10 @@
// 1. Complete the divide function
// 2. Uncomment and complete the second part of the main function
// For part 2 there is a minor hint around line 100 and a major hint around line 128
-// There is a minor side quest in the "print_result_with_list" function
+// There are some final comments for when you are done around line 150
// Have fun :-)
+
// In production code you would not derive Debug, but implement it manually to get a better error message.
#[derive(Debug,PartialEq,Eq)]
enum DivisionError {
@@ -19,27 +20,6 @@ struct NotDivisibleError {
// This function calculates a/b if a is divisible by b.
// Otherwise it returns a suitable error.
fn divide(a: i32, b: i32) -> Result<i32,DivisionError> {
- if b == 0 {
-
- }
- match a % b {
-
- }
-}
-
-// these print functions exist, so you have to satisfy their input types in the main function
-fn print_list_of_results(l: Vec<Result<i32,DivisionError>>) {
- println!("{:?}", l);
-}
-fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
- // side quest: why is there no semicolon in this function?
- match r {
- Ok(v) => println!("All numbers were successfully divided: {:?}", v),
- Err(e) => match e {
- DivisionError::NotDivisible(nde) => println!("Failed to divide {} by {}: Not divisible!", nde.divident, nde.divisor),
- DivisionError::DivideByZero => println!("Can't divide by zero"),
- },
- };
}
#[allow(dead_code)]
@@ -54,23 +34,28 @@ fn main() {
assert_eq!(divide(81,9),Ok(9));
assert_eq!(divide(81,6),Err(DivisionError::NotDivisible(NotDivisibleError{divident:81,divisor:6})));
assert_eq!(divide(81,0),Err(DivisionError::DivideByZero));
+ assert_eq!(divide(0,81),Ok(0));
println!("Your divide function seems to work! Good Job.");
/* Second part of main. Uncomment to continue.
+ // Don't change these numbers. It will break the assertions later in the code.
let numbers = vec![27,297,38502,81];
let division_results = // Do not convert the results into a Vec yet. Leave them iterable for now.
let operation_mode = OperationMode::ResultWithList;
match operation_mode {
OperationMode::ResultWithList => {
-
- print_result_with_list(x);
+
+ println!("{:?}", x);
+ assert_eq!(format!("{:?}",x), "Ok([1, 11, 1426, 3])");
},
OperationMode::ListOfResults => {
-
- print_list_of_results(x);
+
+ println!("{:?}", x);
+ assert_eq!(format!("{:?}",x), "[Ok(1), Ok(11), Ok(1426), Ok(3)]");
},
- } */
+ }
+ */
}
@@ -90,6 +75,20 @@ fn main() {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -126,3 +125,40 @@ fn main() {
// Major hint: Have a look at the Iter trait and at the explanation of its collect function. Especially the part about Result is interesting.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Final comments
+// When you call the function `print_result_with_list` with x, you don't need any type annotations on x anymore.
+// The compiler can infer its type through the function's input type.
+
+#[allow(dead_code)]
+// Don't use this function to solve the exercise
+fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
+ // side quest: why is there no semicolon in this function?
+ match r {
+ Ok(v) => println!("All numbers were successfully divided: {:?}", v),
+ Err(e) => match e {
+ DivisionError::NotDivisible(nde) => println!("Failed to divide {} by {}: Not divisible!", nde.divident, nde.divisor),
+ DivisionError::DivideByZero => println!("Can't divide by zero"),
+ },
+ };
+}
diff --git a/standard_library_types/iterator1_solution.rs b/standard_library_types/iterator1_solution.rs
index daca1e4..87f97f2 100644
--- a/standard_library_types/iterator1_solution.rs
+++ b/standard_library_types/iterator1_solution.rs
@@ -23,10 +23,13 @@ fn divide(a: i32, b: i32) -> Result<i32,DivisionError> {
}
}
-// these print functions exist, so you have to satisfy their input types in the main function
-fn print_list_of_results(l: Vec<Result<i32,DivisionError>>) {
- println!("{:?}", l);
+#[allow(dead_code)]
+enum OperationMode {
+ ListOfResults,
+ ResultWithList,
}
+
+#[allow(dead_code)]
fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
// side quest: why is there no semicolon in this function?
match r {
@@ -38,12 +41,6 @@ fn print_result_with_list(r: Result<Vec<i32>,DivisionError>) {
};
}
-#[allow(dead_code)]
-enum OperationMode {
- ListOfResults,
- ResultWithList,
-}
-
fn main() {
// These asserts check that your `divide` function works.
// In production code these would be tests
@@ -51,6 +48,7 @@ fn main() {
assert_eq!(divide(81,6),Err(DivisionError::NotDivisible(NotDivisibleError{divident:81,divisor:6})));
assert_eq!(divide(81,0),Err(DivisionError::DivideByZero));
println!("Your divide function seems to work! Good Job.");
+ // Don't change these numbers. It will break the assertions later in the code.
let numbers = vec![27,297,38502,81];
let numbers_iterator = numbers.into_iter();
let division_results = numbers_iterator.map(|n| divide(n, 27));
@@ -58,11 +56,13 @@ fn main() {
match operation_mode {
OperationMode::ResultWithList => {
let x : Result<Vec<_>,_> = division_results.collect();
- print_result_with_list(x);
+ //print_result_with_list(x);
+ assert_eq!(format!("{:?}",x), "Ok([1, 11, 1426, 3])");
},
OperationMode::ListOfResults => {
let x : Vec<_> = division_results.collect();
- print_list_of_results(x);
+ println!("{:?}", x);
+ assert_eq!(format!("{:?}",x), "[Ok(1), Ok(11), Ok(1426), Ok(3)]");
},
}
}