How do I write the transpose function example from Rust by Example? - rust

Question

I'm following the Rust by Example tutorial and am on the second part of the Tuples activity which is to add a transpose function using the reverse function as a template. This will accept a matrix as an argument and return a matrix in which two elements have been swapped. For example:
println!("Matrix:\n{}", matrix);
println!("Transpose:\n{}", transpose(matrix));
Expected results:
Input Matrix:
( 1.1 1.2 2.1 2.2 )
Transposed output:
( 1.1 2.1 1.2 2.2 )
I can't find the right code, here is what I'm trying:
// this is defined in the tutorial
#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);
// this is my attempt that does not compile
fn transpose(maat: Matrix) -> (Matrix) {
let matrix = maat;
(matrix.0, matrix.2, matrix.1, matrix.3)
}

Answer 1

I don't want to give you the full solution because i would do you a disservice if you're learning Rust.
There's a key ingredient that you're missing at this point of the tutorial. Not your fault.
Matrix is a "tuple struct" (also sometimes called a newtype) and it's covered in a later section of Rust by example.
If you want to peek ahead, in the section on structs you'll learn the two pieces you're missing.
Piece one: struct Matrix(f32, f32, f32, f32); as defined in the tutorial can be destructured in a similar way as the simple tuple.
If you have a let matrix = Matrix(1.1, 1.2, 2.1, 2.2); you can do this to create names for its individual elements:
let Matrix(r1c1, r2c2, r2c1, r2c2) = matrix
What you did (matrix.0, matrix.1...) works too, though...
Piece two. When you want to create a new instance of Matrix, you do Matrix(1.1, 1.2, 2.1, 2.2). From your attempt at writing transpose you're trying to return a tuple, but a tuple struct like Matrix is a different, incompatible type (that's why it's also called a "newtype")

Answer 2

Using reverse as the example says and rewriting the reverse function to accept f32,
fn reverse(pair: (f32, f32)) -> (f32, f32) {
let (a, b) = pair;
(b, a)
}
fn transpose(mat: Matrix) -> Matrix {
let (a, b) = reverse((mat.1, mat.2));
Matrix(mat.0, a, b, mat.3)
}

Answer 3

You need to do three things here:
Tell the Display format how to structure the output so that it divides the Matrix into two rows of equal length.
impl fmt::Display for Matrix {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "( {} {} )\n( {} {} )", self.0, self.1, self.2, self.3)
}
}
Write the transpose function that will return the matrix in transposed order.
fn transpose(mat: Matrix) -> Matrix {
return Matrix(mat.0, mat.2, mat.1, mat.3);
}
call it inside println
println!("Transpose:\n{}", transpose(matrix));