Why unable to parse a string | Rust - parsing

Question

I am making decimal to binary conversion program. Why am i unable to parse a string into a number? binary_vec[i] is a character. I applied to_string() method to convert it into a string because parse() doesn't apply to a character, but it still giving me an error.
use std::io;
fn main() {
let mut binary = String::new();
println!("Enter a decimal: ");
io::stdin().read_line(&mut binary)
.ok()
.expect("Couldn't read line");
println!("{}",to_decimal(binary));
}
fn to_decimal(mut binary_str:String) -> String {
let mut binary_no: u32 = binary_str.trim().parse().expect("invalid input");
if binary_no == 0 {
format!("{}",binary_no)
}
else {
let mut bits = String::new();
let mut binary_vec: Vec<char> = binary_str.chars().collect();
let mut result = 0;
let mut i = 0;
while i <=binary_str.len()-2{
let mut result = result + (binary_vec[i].to_string().parse::<u32>().unwrap() * 2^(i as u32));
i = i +1;
}
format!("{}",result)
}
}
Result:
Compiling sixteen v0.1.0 (C:\Users\Muhammad.3992348\Desktop\rust\hackathon\sixteen)
warning: unused variable: `bits`
--> src\main.rs:19:17
|
19 | let mut bits = String::new();
| ^^^^ help: consider prefixing with an underscore: `_bits`
|
= note: #[warn(unused_variables)] on by default
warning: unused variable: `result`
--> src\main.rs:24:21
|
24 | let mut result = result + (binary_vec[i].to_string().parse::<u32>().unwrap() * 2^(i as u32));
| ^^^^^^ help: consider prefixing with an underscore: `_result`
warning: variable does not need to be mutable
--> src\main.rs:13:15
|
13 | fn to_decimal(mut binary_str:String) -> String {
| ----^^^^^^^^^^
| |
| help: remove this `mut`
|
= note: #[warn(unused_mut)] on by default
warning: variable does not need to be mutable
--> src\main.rs:14:9
|
14 | let mut binary_no: u32 = binary_str.trim().parse().expect("invalid input");
| ----^^^^^^^^^
| |
| help: remove this `mut`
warning: variable does not need to be mutable
--> src\main.rs:19:13
|
19 | let mut bits = String::new();
| ----^^^^
| |
| help: remove this `mut`
warning: variable does not need to be mutable
--> src\main.rs:20:13
|
20 | let mut binary_vec: Vec<char> = binary_str.chars().collect();
| ----^^^^^^^^^^
| |
| help: remove this `mut`
warning: variable does not need to be mutable
--> src\main.rs:21:13
|
21 | let mut result = 0;
| ----^^^^^^
| |
| help: remove this `mut`
warning: variable does not need to be mutable
--> src\main.rs:24:17
|
24 | let mut result = result + (binary_vec[i].to_string().parse::<u32>().unwrap() * 2^(i as u32));
| ----^^^^^^
| |
| help: remove this `mut`
Finished dev [unoptimized + debuginfo] target(s) in 1.04s
Running `target\debug\sixteen.exe`
Enter a decimal:
100
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src\libcore\result.rs:997:5
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
error: process didn't exit successfully: `target\debug\sixteen.exe` (exit code: 101)
Edit:
I have input 100 and I expect to get 4 at output.

Answer 1

There are a lot of problems with the code as written. The good news is that you can fix most of the problems by listening to the compiler warnings!
--> src/main.rs:19:17
|
19 | let mut bits = String::new();
| ^^^^ help: consider prefixing with an underscore: `_bits`
|
= note: #[warn(unused_variables)] on by default
This tells you that the variable bits isn't used after this declaration. If you intend to use it later, you can just comment it out for now.
warning: unused variable: `result`
--> src/main.rs:24:21
|
24 | let mut result = result + (binary_vec[i].to_string().parse::<u32>().unwrap() * 2^(i as u32));
| ^^^^^^ help: consider prefixing with an underscore: `_result`
|
= note: #[warn(unused_variables)] on by default
This is the big one. This tells us that the variable result is unused. But wait! we're using it right here! Nope! Actually, by using let mut here, we're making a new variable and shadowing the old one. What you want is to instead overwrite the old value. Simply change let mut result = ... to result = ....
Now if we run the program again and input 100, we'll get an output of 5. This still doesn't seem right, but we still have a few warnings to fix, so let's come back to this.
warning: variable does not need to be mutable
--> src/main.rs:13:15
|
13 | fn to_decimal(mut binary_str:String) -> String {
| ----^^^^^^^^^^
| |
| help: remove this `mut`
|
= note: #[warn(unused_mut)] on by default
If we aren't going to mutate the input string, we shouldn't make it mutable. Just remove the mut. Same for the other two warnings (lines 14 and 20).
Alright! Now we can run the program without any warnings. However, there are some more advanced lints we can run using cargo clippy. If you don't have clippy installed yet, you can install it with rustup install component clippy.
Now we have a few more warnings to take care of.
warning: operator precedence can trip the unwary
--> src/main.rs:24:32
|
24 | result = result + (binary_vec[i].to_string().parse::<u32>().unwrap() * 2^(i as u32));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `(binary_vec[i].to_string().parse::<u32>().unwrap() * 2) ^ (i as u32)`
|
= note: #[warn(clippy::precedence)] on by default
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#precedence
Uh oh. Clippy is telling us that the precedence rules indicate that * is evaluated before ^. That's not what we'd expect from multiplication and exponents. It turns out that ^ is not the exponent operator. Instead, it's the bitwise xor. If we want powers of a number, we can use the pow method, so replace 2 ^ (i as u32) with 2.pow(i as u32). This will cause a compiler error with the message error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`. Ok. We can make the numeric type unambiguous using a suffix. Change it to 2_u32.pow(i as u32).
We can fix the other three warnings that Clippy gives us just by using the suggestion. After that, Clippy gives one more warning, which also is fixed with just the suggestion.
Before we continue, let's make our code a bit prettier by running cargo fmt. Finally, the code looks like this:
use std::io;
fn main() {
let mut binary = String::new();
println!("Enter a decimal: ");
io::stdin()
.read_line(&mut binary)
.expect("Couldn't read line");
println!("{}", to_decimal(binary));
}
fn to_decimal(binary_str: String) -> String {
let binary_no: u32 = binary_str.trim().parse().expect("invalid input");
if binary_no == 0 {
format!("{}", binary_no)
} else {
//let mut bits = String::new();
let binary_vec: Vec<char> = binary_str.chars().collect();
let mut result = 0;
let mut i = 0;
while i <= binary_str.len() - 2 {
result += binary_vec[i].to_string().parse::<u32>().unwrap() * 2_u32.pow(i as u32);
i += 1;
}
format!("{}", result)
}
}
We fixed two bugs and cleaned up the code only using compiler warnings and basic tools! Pretty good, eh? But now if we input 100, our output is 1. That isn't right. Let's add some debug statements to see if we can see what's going on.
result += dbg!(binary_vec[i].to_string().parse::<u32>().unwrap()) * dbg!(2_u32.pow(i as u32));
If we run it now, here's what we get.
Enter a decimal:
100
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 1
[src/main.rs:22] 2u32.pow(i as u32) = 1
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 0
[src/main.rs:22] 2u32.pow(i as u32) = 2
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 0
[src/main.rs:22] 2u32.pow(i as u32) = 4
1
We can see that it's parsing the digits correctly: binary_vec[i].to_string().parse::<u32>().unwrap() is 1, then 0, then 0. The powers of 2 look fine too. The problem here is that it's backwards! We want the left digit to be multiplied with the highest power of 2. Let me note that this is the part of the code where you're the least idiomatic. It's much better to use, at the very least, a for loop for this kind of thing. Iterators would be even better if you can manage it.
In any case, we can reverse the order by making our powers go from binary_str.len() - 2 down to 0 instead of the other way around. Thus, we can change the code to
while i <= binary_str.len() - 2 {
result += dbg!(binary_vec[i].to_string().parse::<u32>().unwrap()) * dbg!(2_u32.pow((binary_str.len() - 2 - i) as u32));
i += 1;
}
We get
Enter a decimal:
100
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 1
[src/main.rs:22] 2u32.pow((binary_str.len() - 2 - i) as u32) = 4
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 0
[src/main.rs:22] 2u32.pow((binary_str.len() - 2 - i) as u32) = 2
[src/main.rs:22] binary_vec[i].to_string().parse::<u32>().unwrap() = 0
[src/main.rs:22] 2u32.pow((binary_str.len() - 2 - i) as u32) = 1
4
so we see that the powers are correctly reversed from 4 down to 1. And our answer is finally correct! Test it on a few more inputs and try to find some edge cases. There are still some more bugs to find. Once you're happy with your code, take out the debug statements.

Answer 2

I would usually try to fix the code, but this one just seems way to convoluted.
Here is a simpler solution:
use std::io;
fn main() {
let mut binary = String::new();
println!("Enter a decimal: ");
io::stdin().read_line(&mut binary)
.expect("Couldn't read line");
match to_decimal(binary) {
Some(num) => println!("{}", num),
None => println!("Not a binary!")
}
}
fn to_decimal(binary_str:String) -> Option<i64> {
let binary_str = binary_str.trim();
let mut out_num = 0;
for c in binary_str.chars() {
match c {
'0' => out_num = out_num * 2,
'1' => out_num = out_num * 2 + 1,
_ => return None
}
}
Some(out_num)
}