Question improvements

Author: postrational

questions/q001.yaml

@@ -10,8 +10,8 @@ question: |-
 
   What will this Rust code print?
 answers:
-- '[2, 3, 4]'
-- '[2, 3, 4, 5]'
+- '`[2, 3, 4]`'
+- '`[2, 3, 4, 5]`'
 - Compilation error
 - Runtime panic
 correct_answer: 2

questions/q002.yaml

@@ -15,10 +15,10 @@ question: |-
 
   What is the output of this code?
 answers:
-- Some([1, 2, 3])
-- Some([4, 5, 6, 7])
-- Some([1, 2, 3, 7])
-- Some([1, 2, 3, 4, 5, 6, 7])
+- '`Some([1, 2, 3])`'
+- '`Some([4, 5, 6, 7])`'
+- '`Some([1, 2, 3, 7])`'
+- '`Some([1, 2, 3, 4, 5, 6, 7])`'
 correct_answer: 2
 expected_output:
 - Some([1, 2, 3, 7])

questions/q222.yaml

@@ -1,19 +1,20 @@
 question: |-
   ```rust
-  // This code simulates a library crate with pub(crate) visibility
-  // In a real scenario, main.rs would be in a separate crate
-
+  // mylib/src/lib.rs
   mod mylib {
       pub mod utils {
-          pub(crate) fn internal_helper() -> i32 { 42 }
-          pub fn public_helper() -> i32 { 24 }
+          pub(crate) fn compute_offset() -> i32 { 42 }
+          pub fn calculate_sum() -> i32 { 24 }
       }
   }
+  ```
 
+  ```rust
+  // main.rs (separate binary crate)
   fn main() {
       use mylib::utils;
-      println!("{}", utils::public_helper());
-      println!("{}", utils::internal_helper());
+      println!("{}", utils::calculate_sum());
+      println!("{}", utils::compute_offset());
   }
   ```
 
@@ -23,24 +24,23 @@ answers:
 - Only the first call works, second fails with "function is private"
 - Only the second call works, first fails with "function is private"
 - Both calls fail because the `utils` module is not accessible
-correct_answer: 0
+correct_answer: 1
 expected_output:
-- '24'
-- '42'
+- 'private function'
 explanation: |-
   This question tests understanding of Rust's `pub(crate)` visibility modifier and
   crate boundaries. The `pub(crate)` modifier makes an item public within the
   defining crate but private across crate boundaries.
 
-  In this code, both `internal_helper()` (marked `pub(crate)`) and
-  `public_helper()` (marked `pub`) are defined in the `mylib` module. Since
+  In this code, both `compute_offset()` (marked `pub(crate)`) and
+  `calculate_sum()` (marked `pub`) are defined in the `mylib` module. Since
   `main()` is in the same crate as the `mylib` module, both functions are
   accessible. The `pub(crate)` visibility allows access from anywhere within the
   same crate, so both function calls succeed and print "24" then "42".
 
   The key distinction is that if `main.rs` were in a separate crate that depends
-  on `mylib` as an external library, then only `public_helper()` would be
-  accessible. The `internal_helper()` function would be private across the crate
+  on `mylib` as an external library, then only `calculate_sum()` would be
+  accessible. The `compute_offset()` function would be private across the crate
   boundary, resulting in a compilation error.
 
   The key takeaway is that `pub(crate)` creates crate-local public visibility -

questions/q237.yaml

@@ -1,32 +1,4 @@
 question: |-
-  ```rust
-  // This represents what a procedural macro might generate
-  // Note: proc_macro is only available in proc-macro crates,
-  // so we're showing a conceptual example here
-
-  // Simulating a derive macro expansion
-  // #[some_derive_macro]
-  struct User {
-      name: String,
-      age: u32,
-  }
-
-  // What the macro might expand to:
-  impl User {
-      fn validate(&self) -> bool {
-          !self.name.is_empty() && self.age > 0
-      }
-  }
-
-  fn main() {
-      let user = User {
-          name: "Alice".to_string(),
-          age: 30,
-      };
-      println!("{}", user.validate());
-  }
-  ```
-
   What is the key difference between declarative macros (`macro_rules!`) and
   procedural macros?
 answers:
@@ -35,8 +7,7 @@ answers:
 - Procedural macros operate on token streams and can run arbitrary Rust code at compile time
 - Declarative macros are more powerful and can generate more complex code
 correct_answer: 2
-expected_output:
-- 'true'
+expected_output: []
 explanation: |-
   This question tests understanding of the fundamental differences between Rust's
   two macro systems: declarative macros (`macro_rules!`) and procedural macros.