Fix more exercises

Author: frank-at-adacore

courses/comprehensive_rust_training/030_types_and_values/99_lab.rst

@@ -25,6 +25,8 @@ When will this function panic?
        }
    }
 
+.. container:: source_include 030_types_and_values/src/030_types_and_values.rs :start-after://ANCHOR-main :code:rust
+
    fn main() {
        let n = 20;
        println!("fib({n}) = {}", fib(n));
@@ -34,17 +36,4 @@ When will this function panic?
 Fibonacci Solution
 ---------------------
 
-.. code:: rust
-
-   fn fib(n: u32) -> u32 {
-       if n < 2 {
-           return n;
-       } else {
-           return fib(n - 1) + fib(n - 2);
-       }
-   }
-
-   fn main() {
-       let n = 20;
-       println!("fib({n}) = {}", fib(n));
-   }
+.. container:: source_include 030_types_and_values/src/030_types_and_values.rs :start-after://ANCHOR-fib :end-before://ANCHOR-main :code:rust

courses/comprehensive_rust_training/030_types_and_values/src/030_types_and_values.rs

@@ -0,0 +1,28 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//ANCHOR-fib
+fn fib(n: u32) -> u32 {
+    if n < 2 {
+        return n;
+    } else {
+        return fib(n - 1) + fib(n - 2);
+    }
+}
+
+//ANCHOR-main
+fn main() {
+    let n = 20;
+    println!("fib({n}) = {}", fib(n));
+}

courses/comprehensive_rust_training/040_control_flow_basics/99_lab.rst

@@ -36,29 +36,10 @@ given initial :rust:`n`.
      todo!("Implement this")
    }
 
-   fn main() {
-       // should be 15
-       println!("Length: {}", collatz_length(11));
-   }
+.. container:: source_include 040_control_flow_basics/src/040_control_flow_basics.rs :start-after://ANCHOR-main :code:rust
 
 ----------------------------
 Collatz Sequence Solution
 ----------------------------
 
-.. code:: rust
-
-   /// Determine the length of the
-   /// collatz sequence beginning at `n`.
-   fn collatz_length(mut n: i32) -> u32 {
-       let mut len = 1;
-       while n > 1 {
-           n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
-           len += 1;
-       }
-       len
-   }
-
-   fn main() {
-       // should be 15
-       println!("Length: {}", collatz_length(11));
-   }
+.. container:: source_include 040_control_flow_basics/src/040_control_flow_basics.rs :start-after://ANCHOR-solution :end-before://ANCHOR-tests :code:rust

courses/comprehensive_rust_training/040_control_flow_basics/src/040_control_flow_basics.rs

@@ -0,0 +1,35 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//ANCHOR-solution
+/// Determine the length of the collatz sequence beginning at `n`.
+fn collatz_length(mut n: i32) -> u32 {
+    let mut len = 1;
+    while n > 1 {
+        n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
+        len += 1;
+    }
+    len
+}
+
+//ANCHOR-tests
+#[test]
+fn test_collatz_length() {
+    assert_eq!(collatz_length(11), 15);
+}
+
+//ANCHOR-main
+fn main() {
+    println!("Length: {}", collatz_length(11));
+}

courses/comprehensive_rust_training/050_tuples_and_arrays/99_lab.rst

@@ -3,7 +3,7 @@ Exercise: Nested Arrays
 =========================
 
 -------------------------
-Nested Arrays Problem
+Nested Arrays Setup
 -------------------------
 
 Arrays can contain other arrays:
@@ -37,6 +37,10 @@ into
       3 & 6 & 9
    \end{bmatrix}
 
+-------------------------
+Nested Arrays Problem
+-------------------------
+
 Copy the code below to https://play.rust-lang.org/ and implement the
 function. This function only operates on 3x3 matrices.
 
@@ -46,42 +50,10 @@ function. This function only operates on 3x3 matrices.
        todo!()
    }
 
-   fn main() {
-       let matrix = [
-           [101, 102, 103], //  comment makes rustfmt add newline
-           [201, 202, 203],
-           [301, 302, 303],
-       ];
-
-       dbg!(matrix);
-       let transposed = transpose(matrix);
-       dbg!(transposed);
-   }
+.. container:: source_include 050_tuples_and_arrays/src/050_tuples_and_arrays.rs :start-after://ANCHOR-main :code:rust
 
 -------------------------
 Nested Arrays Solution
 -------------------------
 
-.. code:: rust
-
-   fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
-       let mut result = [[0; 3]; 3];
-       for i in 0..3 {
-           for j in 0..3 {
-               result[j][i] = matrix[i][j];
-           }
-       }
-       result
-   }
-
-   fn main() {
-       let matrix = [
-           [101, 102, 103], //  comment makes rustfmt add newline
-           [201, 202, 203],
-           [301, 302, 303],
-       ];
-
-       dbg!(matrix);
-       let transposed = transpose(matrix);
-       dbg!(transposed);
-   }
+.. container:: source_include 050_tuples_and_arrays/src/050_tuples_and_arrays.rs :start-after://ANCHOR-solution :code:rust :end-before://ANCHOR-tests

courses/comprehensive_rust_training/050_tuples_and_arrays/src/050_tuples_and_arrays.rs

@@ -0,0 +1,56 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//ANCHOR-solution
+fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
+    let mut result = [[0; 3]; 3];
+    for i in 0..3 {
+        for j in 0..3 {
+            result[j][i] = matrix[i][j];
+        }
+    }
+    result
+}
+
+//ANCHOR-tests
+#[test]
+fn test_transpose() {
+    let matrix = [
+        [101, 102, 103], //
+        [201, 202, 203],
+        [301, 302, 303],
+    ];
+    let transposed = transpose(matrix);
+    assert_eq!(
+        transposed,
+        [
+            [101, 201, 301], //
+            [102, 202, 302],
+            [103, 203, 303],
+        ]
+    );
+}
+
+//ANCHOR-main
+fn main() {
+    let matrix = [
+        [101, 102, 103], // <-- the comment makes rustfmt add a newline
+        [201, 202, 203],
+        [301, 302, 303],
+    ];
+
+    println!("matrix: {:#?}", matrix);
+    let transposed = transpose(matrix);
+    println!("transposed: {:#?}", transposed);
+}

courses/comprehensive_rust_training/060_references/99_lab.rst

@@ -10,7 +10,7 @@ We will create a few utility functions for 3-dimensional geometry,
 representing a point as :rust:`[f64;3]`. It is up to you to determine the
 function signatures.
 
-::
+.. code:: rust
 
    // Calculate the magnitude of a vector by summing the squares of its coordinates
    // and taking the square root. Use the `sqrt()` method to calculate the square
@@ -27,48 +27,15 @@ function signatures.
        todo!()
    }
 
-   // Use the following `main` to test your work.
-
-   fn main() {
-       println!("Magnitude of a unit vector: {}", magnitude(&[0.0, 1.0, 0.0]));
+Use the following :rust:`main` to test your work.
 
-       let mut v = [1.0, 2.0, 9.0];
-       println!("Magnitude of {v:?}: {}", magnitude(&v));
-       normalize(&mut v);
-       println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
-   }
+.. container:: source_include 060_references/src/060_references.rs :start-after://ANCHOR-main :code:rust
 
 --------------------
 Geometry Solution
 --------------------
 
-.. code:: rust
-
-   /// Calculate the magnitude of the given vector.
-   fn magnitude(vector: &[f64; 3]) -> f64 {
-       let mut mag_squared = 0.0;
-       for coord in vector {
-           mag_squared += coord * coord;
-       }
-       mag_squared.sqrt()
-   }
-
-   /// Change the magnitude of the vector to 1.0 without changing its direction.
-   fn normalize(vector: &mut [f64; 3]) {
-       let mag = magnitude(vector);
-       for item in vector {
-           *item /= mag;
-       }
-   }
-
-   fn main() {
-       println!("Magnitude of a unit vector: {}", magnitude(&[0.0, 1.0, 0.0]));
-
-       let mut v = [1.0, 2.0, 9.0];
-       println!("Magnitude of {v:?}: {}", magnitude(&v));
-       normalize(&mut v);
-       println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
-   }
+.. container:: source_include 060_references/src/060_references.rs :start-after://ANCHOR-solution :end-before://ANCHOR-main :code:rust
 
 ------------------------
 Additional Information

courses/comprehensive_rust_training/060_references/src/060_references.rs

@@ -0,0 +1,41 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//ANCHOR-solution
+/// Calculate the magnitude of the given vector.
+fn magnitude(vector: &[f64; 3]) -> f64 {
+    let mut mag_squared = 0.0;
+    for coord in vector {
+        mag_squared += coord * coord;
+    }
+    mag_squared.sqrt()
+}
+
+/// Change the magnitude of the vector to 1.0 without changing its direction.
+fn normalize(vector: &mut [f64; 3]) {
+    let mag = magnitude(vector);
+    for item in vector {
+        *item /= mag;
+    }
+}
+
+//ANCHOR-main
+fn main() {
+    println!("Magnitude of a unit vector: {}", magnitude(&[0.0, 1.0, 0.0]));
+
+    let mut v = [1.0, 2.0, 9.0];
+    println!("Magnitude of {v:?}: {}", magnitude(&v));
+    normalize(&mut v);
+    println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
+}