From d989bbebd0f1d46529c341afff2239bac68e041d Mon Sep 17 00:00:00 2001 From: Constantin Berhard 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 { + 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>) { + println!("{:?}", l); +} +fn print_result_with_list(r: Result,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 { + 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>) { + println!("{:?}", l); +} +fn print_result_with_list(r: Result,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,_> = 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 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 { - 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>) { - println!("{:?}", l); -} -fn print_result_with_list(r: Result,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,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 { } } -// these print functions exist, so you have to satisfy their input types in the main function -fn print_list_of_results(l: Vec>) { - println!("{:?}", l); +#[allow(dead_code)] +enum OperationMode { + ListOfResults, + ResultWithList, } + +#[allow(dead_code)] fn print_result_with_list(r: Result,DivisionError>) { // side quest: why is there no semicolon in this function? match r { @@ -38,12 +41,6 @@ fn print_result_with_list(r: Result,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,_> = 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)]"); }, } }