Solution

1. ```
   fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
   ```
2. ```
       let mut result = [[0; 3]; 3];
   ```
3. ```
       for i in 0..3 {
   ```
4. ```
           for j in 0..3 {
   ```
5. ```
               result[j][i] = matrix[i][j];
   ```
6. ```
           }
   ```
7. ```
       }
   ```
8. ```
       result
   ```
9. ```
   }
   ```

11. ```
    #[test]
    ```
12. ```
    fn test_transpose() {
    ```
13. ```
        let matrix = [
    ```
14. ```
            [101, 102, 103], //
    ```
15. ```
            [201, 202, 203],
    ```
16. ```
            [301, 302, 303],
    ```
17. ```
        ];
    ```
18. ```
        let transposed = transpose(matrix);
    ```
19. ```
        assert_eq!(
    ```
20. ```
            transposed,
    ```
21. ```
            [
    ```
22. ```
                [101, 201, 301], //
    ```
23. ```
                [102, 202, 302],
    ```
24. ```
                [103, 203, 303],
    ```
25. ```
            ]
    ```
26. ```
        );
    ```
27. ```
    }
    ```

29. ```
    fn main() {
    ```
30. ```
        let matrix = [
    ```
31. ```
            [101, 102, 103], // <-- the comment makes rustfmt add a newline
    ```
32. ```
            [201, 202, 203],
    ```
33. ```
            [301, 302, 303],
    ```
34. ```
        ];
    ```

36. ```
        println!("matrix: {:#?}", matrix);
    ```
37. ```
        let transposed = transpose(matrix);
    ```
38. ```
        println!("transposed: {:#?}", transposed);
    ```
39. ```
    }
    ```