style(clippy): idiom sweep across lib/common, mylang, and checker (refs #22) (#25)

Mechanical idiom upgrades flagged by clippy. No behaviour change in
any path; all touched modules continue to test green.

checker.rs (6 sites): `if let Err(_) = X { .. }` -> `if X.is_err() { .. }`
  for `define_effect`, `define_ai_model`, `define_prompt`, function
  symbol define, parameter symbol define, and variable symbol define.

checker.rs:773: drop the unused `.enumerate()` whose index was already
  discarded via `_i`; iterate the zipped pair directly.

lib/common/string.rs:
* `radix < 2 || radix > 36` -> `!(2..=36).contains(&radix)`
* two `std::iter::repeat(pad).take(N)` sites -> `std::iter::repeat_n(pad, N)`
  (stable since Rust 1.82).

lib/common/types.rs:
* `radix < 2 || radix > 36` -> `!(2..=36).contains(&radix)`
* `assert_eq!(int_to_bool(0), false)` / `assert_eq!(.., true)` ->
  `assert!(!..)` / `assert!(..)`.

lib/common/utils.rs:
* `self.next_u64() % 2 == 0` -> `self.next_u64().is_multiple_of(2)`
* two `r >= 0.0 && r < 1.0` -> `(0.0..1.0).contains(&r)`
* `r >= 5 && r <= 10` -> `(5..=10).contains(&r)`.

lib/common/array.rs:313: `slice(&vec![1,2,3,4,5], ..)` ->
  `slice(&[1,2,3,4,5], ..)` (clippy::useless_vec).

lib/mylang/ai.rs:26 and lib/mylang/prompt.rs:139: keep `AiModelType::
  from_str` and `PromptBuilder::add` as they are, but annotate each
  with `#[allow(clippy::should_implement_trait)]` plus a one-line
  rationale. Implementing `FromStr` would force callers to `.unwrap()`
  an `Infallible` (the classifier never fails). Implementing
  `std::ops::Add` would be wrong shape for a fluent builder (`+` ate
  two operands and consumes them; `add` here chains).

Out of scope for this PR (kept clean):
* parser.rs `errors.len() > 0` x6 -- in test code that overlaps with
  the depth-guard PR (#21); will land cleanly once #21 merges.
* `approx_constant` errors (PR1, #23) and the two real correctness
  bugs (PR2, #24) -- handled in their own branches.

Part 3 of 4 from #22. Off clean origin/main; does not depend on PR1
(#23) or PR2 (#24).

Author: hyperpolymath

crates/my-lang/lib/common/array.rs

@@ -310,7 +310,7 @@ mod tests {
         let a = vec![1, 2];
         let b = vec![3, 4];
         assert_eq!(concat(&a, &b), vec![1, 2, 3, 4]);
-        assert_eq!(slice(&vec![1, 2, 3, 4, 5], 1, 4), vec![2, 3, 4]);
+        assert_eq!(slice(&[1, 2, 3, 4, 5], 1, 4), vec![2, 3, 4]);
     }
 
     #[test]

crates/my-lang/lib/common/string.rs

@@ -135,7 +135,7 @@ pub fn pad_start(s: &str, len: usize, pad: char) -> String {
     if s.len() >= len {
         s.to_string()
     } else {
-        let padding: String = std::iter::repeat(pad).take(len - s.len()).collect();
+        let padding: String = std::iter::repeat_n(pad, len - s.len()).collect();
         format!("{}{}", padding, s)
     }
 }
@@ -145,7 +145,7 @@ pub fn pad_end(s: &str, len: usize, pad: char) -> String {
     if s.len() >= len {
         s.to_string()
     } else {
-        let padding: String = std::iter::repeat(pad).take(len - s.len()).collect();
+        let padding: String = std::iter::repeat_n(pad, len - s.len()).collect();
         format!("{}{}", s, padding)
     }
 }
@@ -197,7 +197,7 @@ pub fn parse_float(s: &str) -> Option<f64> {
 
 /// Format integer to string with radix
 pub fn int_to_string_radix(n: i64, radix: u32) -> Option<String> {
-    if radix < 2 || radix > 36 {
+    if !(2..=36).contains(&radix) {
         return None;
     }
 

crates/my-lang/lib/common/types.rs

@@ -91,7 +91,7 @@ pub fn int_to_str(n: i64) -> String {
 
 /// Convert integer to string with radix
 pub fn int_to_str_radix(n: i64, radix: u32) -> Option<String> {
-    if radix < 2 || radix > 36 {
+    if !(2..=36).contains(&radix) {
         return None;
     }
 
@@ -331,8 +331,8 @@ mod tests {
         assert_eq!(str_to_bool("false"), Some(false));
         assert_eq!(str_to_bool("yes"), Some(true));
         assert_eq!(str_to_bool("no"), Some(false));
-        assert_eq!(int_to_bool(0), false);
-        assert_eq!(int_to_bool(1), true);
+        assert!(!int_to_bool(0));
+        assert!(int_to_bool(1));
     }
 
     #[test]

crates/my-lang/lib/common/utils.rs

@@ -95,7 +95,7 @@ impl SimpleRng {
 
     /// Generate random bool
     pub fn next_bool(&mut self) -> bool {
-        self.next_u64() % 2 == 0
+        self.next_u64().is_multiple_of(2)
     }
 
     /// Generate random bool with probability p of being true
@@ -294,15 +294,15 @@ mod tests {
         let r1 = random();
         let r2 = random();
         // Random numbers should be in [0, 1)
-        assert!(r1 >= 0.0 && r1 < 1.0);
-        assert!(r2 >= 0.0 && r2 < 1.0);
+        assert!((0.0..1.0).contains(&r1));
+        assert!((0.0..1.0).contains(&r2));
     }
 
     #[test]
     fn test_random_int() {
         for _ in 0..100 {
             let r = random_int(5, 10);
-            assert!(r >= 5 && r <= 10);
+            assert!((5..=10).contains(&r));
         }
     }
 

crates/my-lang/lib/mylang/ai.rs

@@ -23,6 +23,11 @@ pub enum AiModelType {
 }
 
 impl AiModelType {
+    // Deliberately not implementing `std::str::FromStr`: this classifier is
+    // infallible (every string maps to *some* variant -- unknown names fall
+    // through to `Local`), so the trait's `Result<Self, Self::Err>` shape
+    // would just force callers to `.unwrap()` an `Infallible` everywhere.
+    #[allow(clippy::should_implement_trait)]
     pub fn from_str(s: &str) -> Self {
         if s.starts_with("gpt-") || s.starts_with("o1") {
             AiModelType::OpenAI(s.to_string())

crates/my-lang/lib/mylang/prompt.rs

@@ -135,7 +135,12 @@ impl PromptBuilder {
         }
     }
 
-    /// Add a part to the prompt
+    /// Add a part to the prompt.
+    ///
+    /// This is a fluent-builder method, not `std::ops::Add::add` (which would
+    /// be the wrong shape -- `Add` is for the `+` operator and consumes two
+    /// values, while this returns `Self` for chaining).
+    #[allow(clippy::should_implement_trait)]
     pub fn add(mut self, text: &str) -> Self {
         self.parts.push(text.to_string());
         self

crates/my-lang/src/checker.rs

@@ -416,7 +416,7 @@ impl Checker {
                     span: e.span,
                 };
 
-                if let Err(_) = self.types.define_effect(def) {
+                if self.types.define_effect(def).is_err() {
                     self.errors.push(CheckError::DuplicateDefinition {
                         name: e.name.name.clone(),
                         line: e.span.line,
@@ -445,7 +445,7 @@ impl Checker {
                     span: m.span,
                 };
 
-                if let Err(_) = self.types.define_ai_model(def) {
+                if self.types.define_ai_model(def).is_err() {
                     self.errors.push(CheckError::DuplicateDefinition {
                         name: m.name.name.clone(),
                         line: m.span.line,
@@ -469,7 +469,7 @@ impl Checker {
                     span: p.span,
                 };
 
-                if let Err(_) = self.types.define_prompt(def) {
+                if self.types.define_prompt(def).is_err() {
                     self.errors.push(CheckError::DuplicateDefinition {
                         name: p.name.name.clone(),
                         line: p.span.line,
@@ -506,13 +506,13 @@ impl Checker {
                     result: Box::new(return_type),
                 };
 
-                if let Err(_) = self.symbols.define(Symbol {
+                if self.symbols.define(Symbol {
                     name: f.name.name.clone(),
                     kind: SymbolKind::Function,
                     ty: fn_type,
                     span: f.span,
                     mutable: false,
-                }) {
+                }).is_err() {
                     self.errors.push(CheckError::DuplicateDefinition {
                         name: f.name.name.clone(),
                         line: f.span.line,
@@ -541,13 +541,13 @@ impl Checker {
         // Add parameters to scope
         for param in &f.params {
             let ty = ast_type_to_ty(&param.ty);
-            if let Err(_) = self.symbols.define(Symbol {
+            if self.symbols.define(Symbol {
                 name: param.name.name.clone(),
                 kind: SymbolKind::Parameter,
                 ty,
                 span: param.span,
                 mutable: false,
-            }) {
+            }).is_err() {
                 self.errors.push(CheckError::DuplicateDefinition {
                     name: param.name.name.clone(),
                     line: param.span.line,
@@ -610,13 +610,13 @@ impl Checker {
                     value_ty
                 };
 
-                if let Err(_) = self.symbols.define(Symbol {
+                if self.symbols.define(Symbol {
                     name: name.name.clone(),
                     kind: SymbolKind::Variable,
                     ty: final_ty,
                     span: *span,
                     mutable: *mutable,
-                }) {
+                }).is_err() {
                     self.errors.push(CheckError::DuplicateDefinition {
                         name: name.name.clone(),
                         line: span.line,
@@ -770,7 +770,7 @@ impl Checker {
                                 column: span.column,
                             });
                         } else {
-                            for (_i, (param, arg)) in params.iter().zip(arg_types.iter()).enumerate() {
+                            for (param, arg) in params.iter().zip(arg_types.iter()) {
                                 if !param.is_assignable_from(arg) && !arg.is_error_or_unknown() {
                                     self.errors.push(CheckError::TypeMismatch {
                                         expected: param.to_string(),