显示带有for循环的矩阵时类型不匹配

Question

Inspired by the code provided by evilone in the post How to print a Vec? . To display a matrix, I wrote code as following:

use std::{ops, fmt};

#[derive(PartialEq, Debug)]
pub struct Matrix<T> {
    data: Vec<T>,
    row: usize,
    col: usize,
}

impl<T: Copy> Matrix<T> {       
    pub fn new(row: usize, col: usize, values: &[T]) -> Matrix<T> {
        Matrix {
            data: values.to_vec(), 
            row: row,
            col: col,
        }
    }
}    

//// Display
impl<T: fmt::Display> fmt::Display for Matrix<T> {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let n_row = self.row;
        let n_col = self.col;
        let data = self.data;

        for i in 0.. n_row {
            let mut each_row = String::new(); 

            for j in 0.. n_col {
                let idx = i * n_col + j;  
                let each_element = data[idx];
                each_row.push_str(&each_element.to_string());
                each_row.push_str(" ");  // seperated by space 
            }
            write!(f, "{}", each_row)   
        }
    }
}    

fn main() {
    let x = Matrix::new(2, 3, &[-6, -5, 0, 1, 2, 3]);
    println!("{}", x);

}

I got the errors:

rustc 1.13.0 (2c6933acc 2016-11-07)
error[E0308]: mismatched types
  --> <anon>:40:13
   |
40 |             write!(f, "{}", each_row)   
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum `std::result::Result`
   |
   = note: expected type `()`
   = note:    found type `std::result::Result<(), std::fmt::Error>`
   = note: this error originates in a macro outside of the current crate

error[E0308]: mismatched types
  --> <anon>:31:9
   |
31 |         for i in 0.. n_row {
   |         ^ expected enum `std::result::Result`, found ()
   |
   = note: expected type `std::result::Result<(), std::fmt::Error>`
   = note:    found type `()`

1) I don't understand why I get expected (), found enum `std::result::Result`

2) For the second error, I thought it was caused by the failure to implement line 40. So if fix line 40, it won't be a problem anymore.

Any suggestions to fix this?

Answer 1

When programming, it's useful to create a Minimal, Complete, and Verifiable Example . This means you remove everything that's not relevant to the error or problem you are having, boiling it down to the pure essence. Generally, you will find that doing so greatly narrows down the potential location of the problem. Often, this allows you to answer the question yourself, and other times it increases the chances of being able to ask an insightful question.

Here's an MCVE for this problem:

fn foo() -> u8 {
    for i in 0..1u8 {
        i
    }
}

fn main() {}

Pretty small, isn't it? It produces these errors:

error[E0308]: mismatched types
 --> src/main.rs:3:9
  |
3 |         i
  |         ^ expected (), found u8
  |
  = note: expected type `()`
  = note:    found type `u8`

error[E0308]: mismatched types
 --> src/main.rs:2:5
  |
2 |     for i in 0..1u8 {
  |     ^ expected u8, found ()
  |
  = note: expected type `u8`
  = note:    found type `()`

Which should look familiar.

Now the question you can ask yourself: what type and value does a for loop evaluate to? (Hint: the compiler messages actually tell you if you read them the right way)

We know that the function must return a u8 , but the compiler tells us that we are actually returning a () — this is the second error. That means that a for loop evaluates to () ! Since a for loop evaluates to () , what could possibly happen to the value that the for loop's block evaluates to? As you can guess, the answer is that the block cannot return a value!

Think about this example:

fn foo() -> u8 {
    for i in 0..0u8 {
        //
    }
}

What would this return? Yeah, probably nothing good.

---

Returning from our MCVE back to the original problem, you need to explicitly return inner failures and explicitly return success at the end of the loop:

for /* ... */ {
    // ...

    try!(write!(f, "{}", each_row))
}

Ok(())

This just opens the door to other errors in the code, but you are capable of figuring those out!