@canonical/code-standards 0.1.0 → 0.1.1

package/data/rust.ttl

@@ -20,16 +20,11 @@ cs:RustCategory a cs:Category ;
 cs:NewtypeWrappers a cs:CodeStandard ;
     cs:name "rust/types/newtype-wrappers" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Use the newtype pattern to create distinct types for domain-specific values, preventing accidental mixing of semantically different data. This Haskell-inspired pattern provides compile-time safety with zero runtime cost.
-
-**Ratings:**
-- Impact: A (prevents mixing semantically different values)
-- Feasibility: B (requires discipline; some boilerplate)
-- Idiomaticity: S (core Rust pattern, zero-cost abstraction)
-- FP Purity: A (Haskell-inspired; phantom types possible)""" ;
-    cs:dos """
-(Do) Wrap primitive types in newtypes for domain semantics.
-```rust
+    cs:description """Use the newtype pattern to create distinct types for domain-specific values, preventing accidental mixing of semantically different data. This Haskell-inspired pattern provides compile-time safety with zero runtime cost.""" ;
+    cs:do [
+        cs:description "Wrap primitive types in newtypes for domain semantics." ;
+        cs:language "rust" ;
+        cs:code """
 /// A validated package name following sem conventions
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PackageName(String);
@@ -50,10 +45,12 @@ impl PackageName {
         &self.0
     }
 }
-```
-
-(Do) Use newtypes to distinguish semantically different IDs.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use newtypes to distinguish semantically different IDs." ;
+        cs:language "rust" ;
+        cs:code """
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct UserId(u64);
 
@@ -65,17 +62,21 @@ fn process_order(user: UserId, order: OrderId) { /* ... */ }
 
 // This won't compile:
 // process_order(order_id, user_id);  // Error: expected UserId, found OrderId
-```
-
-(Do) Derive common traits to maintain ergonomics.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Derive common traits to maintain ergonomics." ;
+        cs:language "rust" ;
+        cs:code """
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct Uri(String);
-```
-
-(Do) Use phantom types for compile-time state tracking.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use phantom types for compile-time state tracking." ;
+        cs:language "rust" ;
+        cs:code """
 use std::marker::PhantomData;
 
 struct Validated;
@@ -98,11 +99,12 @@ impl Input<Validated> {
         // Only validated inputs can be processed
     }
 }
-```
-""" ;
-    cs:donts """
-(Don't) Use raw primitive types for domain concepts.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use raw primitive types for domain concepts." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Raw strings lose semantic meaning
 fn load_package(name: String, path: String, uri: String) {
     // Easy to mix up arguments - compiler can't help
@@ -110,10 +112,12 @@ fn load_package(name: String, path: String, uri: String) {
 
 // Bad: Easy to accidentally swap arguments
 load_package(uri, name, path);  // Compiles but wrong!
-```
-
-(Don't) Create newtypes without validation when invariants exist.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Create newtypes without validation when invariants exist." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Allows invalid state
 pub struct Email(pub String);  // pub field allows any string
 
@@ -128,15 +132,17 @@ impl Email {
         }
     }
 }
-```
-
-(Don't) Over-wrap types that don't need semantic distinction.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Over-wrap types that don't need semantic distinction." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Unnecessary wrapping of implementation details
 struct LoopCounter(usize);  // Just use usize
 struct TempBuffer(Vec<u8>);  // Just use Vec<u8>
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 2: Error Context Enrichment
@@ -145,16 +151,11 @@ struct TempBuffer(Vec<u8>);  // Just use Vec<u8>
 cs:ErrorContextEnrichment a cs:CodeStandard ;
     cs:name "rust/errors/context-enrichment" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Always enrich errors with contextual information such as file paths, operation names, and relevant state. This dramatically improves debugging experience and follows the principle of errors as values.
-
-**Ratings:**
-- Impact: S (dramatically improves debugging experience)
-- Feasibility: A (thiserror + map_err pattern already established)
-- Idiomaticity: S (Rust community best practice)
-- FP Purity: B (error as value; monadic error propagation)""" ;
-    cs:dos """
-(Do) Use thiserror to create structured, contextual error types.
-```rust
+    cs:description """Always enrich errors with contextual information such as file paths, operation names, and relevant state. This dramatically improves debugging experience and follows the principle of errors as values.""" ;
+    cs:do [
+        cs:description "Use thiserror to create structured, contextual error types." ;
+        cs:language "rust" ;
+        cs:code """
 use thiserror::Error;
 use std::path::PathBuf;
 
@@ -182,10 +183,12 @@ pub enum GraphError {
         message: String,
     },
 }
-```
-
-(Do) Use map_err to add context when propagating errors.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use map_err to add context when propagating errors." ;
+        cs:language "rust" ;
+        cs:code """
 fn load_package(path: &Path) -> Result<Package, GraphError> {
     let content = fs::read_to_string(path)
         .map_err(|e| GraphError::FileRead {
@@ -201,10 +204,12 @@ fn load_package(path: &Path) -> Result<Package, GraphError> {
 
     Ok(Package::from_manifest(manifest))
 }
-```
-
-(Do) Chain errors to preserve the full error trail.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Chain errors to preserve the full error trail." ;
+        cs:language "rust" ;
+        cs:code """
 #[derive(Error, Debug)]
 pub enum AppError {
     #[error("Failed to load configuration")]
@@ -220,10 +225,12 @@ pub enum AppError {
         source: GraphError,
     },
 }
-```
-
-(Do) Include actionable information in error messages.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Include actionable information in error messages." ;
+        cs:language "rust" ;
+        cs:code """
 #[derive(Error, Debug)]
 pub enum ValidationError {
     #[error("Package name '{name}' is invalid: {reason}. Valid names contain only alphanumeric characters, hyphens, and underscores.")]
@@ -232,11 +239,12 @@ pub enum ValidationError {
         reason: &'static str,
     },
 }
-```
-""" ;
-    cs:donts """
-(Don't) Use generic string errors that lose context.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use generic string errors that lose context." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Loses type information and context
 fn load_config(path: &Path) -> Result<Config, String> {
     let content = fs::read_to_string(path)
@@ -245,10 +253,12 @@ fn load_config(path: &Path) -> Result<Config, String> {
     toml::from_str(&content)
         .map_err(|e| e.to_string())  // Which file? What went wrong?
 }
-```
-
-(Don't) Discard error information with unwrap or expect in library code.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Discard error information with unwrap or expect in library code." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Panics instead of propagating
 fn parse_uri(s: &str) -> Uri {
     Uri::parse(s).unwrap()  // Crashes on invalid input!
@@ -256,19 +266,23 @@ fn parse_uri(s: &str) -> Uri {
 
 // Bad: expect without context
 let file = File::open(path).expect("failed");  // Which path?
-```
-
-(Don't) Create error types without Display or Debug.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Create error types without Display or Debug." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Unusable error type
 pub struct MyError {
     code: i32,
     // No Display impl - can't print meaningful message
 }
-```
-
-(Don't) Use anyhow/eyre in library code (ok for applications).
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use anyhow/eyre in library code (ok for applications)." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad in libraries: Erases type information
 pub fn process() -> anyhow::Result<()> {
     // Callers can't match on specific error variants
@@ -278,8 +292,8 @@ pub fn process() -> anyhow::Result<()> {
 pub fn process() -> Result<(), ProcessError> {
     // Callers can handle specific cases
 }
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 3: Result Chaining (Monadic Composition)
@@ -288,16 +302,11 @@ pub fn process() -> Result<(), ProcessError> {
 cs:ResultChaining a cs:CodeStandard ;
     cs:name "rust/composition/result-chaining" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Use monadic Result chaining with the ? operator and combinators like and_then, map, and or_else for clean, composable error handling. This is the Rust equivalent of Haskell's do-notation for the Either monad.
-
-**Ratings:**
-- Impact: A (cleaner control flow, eliminates nested matches)
-- Feasibility: S (already natural in Rust)
-- Idiomaticity: S (idiomatic Rust; ? operator is standard)
-- FP Purity: S (direct monadic composition / Kleisli arrows)""" ;
-    cs:dos """
-(Do) Use the ? operator for clean Result propagation.
-```rust
+    cs:description """Use monadic Result chaining with the ? operator and combinators like and_then, map, and or_else for clean, composable error handling. This is the Rust equivalent of Haskell's do-notation for the Either monad.""" ;
+    cs:do [
+        cs:description "Use the ? operator for clean Result propagation." ;
+        cs:language "rust" ;
+        cs:code """
 fn load_project_graph() -> Result<(SemStore, Vec<PackageGraph>), GraphError> {
     let project_root = find_project_root()
         .ok_or(GraphError::NoProjectRoot)?;
@@ -318,20 +327,24 @@ fn load_project_graph() -> Result<(SemStore, Vec<PackageGraph>), GraphError> {
 
     Ok((store, package_graphs))
 }
-```
-
-(Do) Use and_then for dependent computations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use and_then for dependent computations." ;
+        cs:language "rust" ;
+        cs:code """
 fn process_user_input(input: &str) -> Result<Output, ProcessError> {
     parse_input(input)
         .and_then(|parsed| validate(parsed))
         .and_then(|valid| transform(valid))
         .and_then(|transformed| save(transformed))
 }
-```
-
-(Do) Use map for infallible transformations within Result.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use map for infallible transformations within Result." ;
+        cs:language "rust" ;
+        cs:code """
 fn get_package_names(path: &Path) -> Result<Vec<String>, IoError> {
     fs::read_dir(path)?
         .filter_map(|entry| entry.ok())
@@ -347,19 +360,23 @@ fn get_config_value(key: &str) -> Result<String, ConfigError> {
         .map(|v| v.to_string())
         .ok_or(ConfigError::MissingKey(key.to_string()))
 }
-```
-
-(Do) Use or_else for fallback computations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use or_else for fallback computations." ;
+        cs:language "rust" ;
+        cs:code """
 fn find_config() -> Result<Config, ConfigError> {
     load_config_from_env()
         .or_else(|_| load_config_from_file())
         .or_else(|_| Ok(Config::default()))
 }
-```
-
-(Do) Combine multiple Results with the ? operator in sequence.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Combine multiple Results with the ? operator in sequence." ;
+        cs:language "rust" ;
+        cs:code """
 fn setup_application() -> Result<App, SetupError> {
     let config = load_config()?;
     let db = connect_database(&config.db_url)?;
@@ -368,11 +385,12 @@ fn setup_application() -> Result<App, SetupError> {
 
     Ok(App { config, db, cache, logger })
 }
-```
-""" ;
-    cs:donts """
-(Don't) Use nested match expressions for Result handling.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use nested match expressions for Result handling." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Deeply nested, hard to follow
 fn process(input: &str) -> Result<Output, Error> {
     match parse(input) {
@@ -390,35 +408,41 @@ fn process(input: &str) -> Result<Output, Error> {
         Err(e) => Err(e.into()),
     }
 }
-```
-
-(Don't) Use unwrap() or expect() to bypass error handling.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use unwrap() or expect() to bypass error handling." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Panics on error
 fn load_data() -> Data {
     let content = fs::read_to_string("data.json").unwrap();
     serde_json::from_str(&content).unwrap()
 }
-```
-
-(Don't) Ignore errors silently.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Ignore errors silently." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Errors are silently dropped
 fn try_save(data: &Data) {
     let _ = fs::write("data.json", serde_json::to_string(data).unwrap_or_default());
 }
-```
-
-(Don't) Convert all errors to strings early in the chain.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Convert all errors to strings early in the chain." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Loses error type information
 fn process() -> Result<(), String> {
     let x = step1().map_err(|e| e.to_string())?;
     let y = step2(x).map_err(|e| e.to_string())?;  // Can't distinguish errors
     Ok(())
 }
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 4: Iterator Combinator Pipelines
@@ -427,16 +451,11 @@ fn process() -> Result<(), String> {
 cs:CombinatorPipelines a cs:CodeStandard ;
     cs:name "rust/iterators/combinator-pipelines" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Prefer iterator combinators (map, filter, flat_map, collect) over imperative loops for data transformations. This functional style is more declarative, composable, and often more performant due to lazy evaluation and compiler optimizations.
-
-**Ratings:**
-- Impact: A (more declarative, composable, often faster)
-- Feasibility: A (Rust iterators are excellent)
-- Idiomaticity: S (core Rust idiom)
-- FP Purity: S (direct FP; lazy evaluation, composable)""" ;
-    cs:dos """
-(Do) Use iterator chains for data transformations.
-```rust
+    cs:description """Prefer iterator combinators (map, filter, flat_map, collect) over imperative loops for data transformations. This functional style is more declarative, composable, and often more performant due to lazy evaluation and compiler optimizations.""" ;
+    cs:do [
+        cs:description "Use iterator chains for data transformations." ;
+        cs:language "rust" ;
+        cs:code """
 fn get_installed_packages() -> Result<Vec<String>, IoError> {
     let packages_path = sem_packages_dir()?;
 
@@ -457,28 +476,34 @@ fn get_installed_packages() -> Result<Vec<String>, IoError> {
     packages.sort();
     Ok(packages)
 }
-```
-
-(Do) Use flat_map for one-to-many transformations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use flat_map for one-to-many transformations." ;
+        cs:language "rust" ;
+        cs:code """
 fn get_all_dependencies(packages: &[Package]) -> Vec<Dependency> {
     packages.iter()
         .flat_map(|pkg| pkg.dependencies())
         .collect()
 }
-```
-
-(Do) Use filter_map to combine filter and map operations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use filter_map to combine filter and map operations." ;
+        cs:language "rust" ;
+        cs:code """
 fn parse_valid_numbers(strings: &[&str]) -> Vec<i32> {
     strings.iter()
         .filter_map(|s| s.parse::<i32>().ok())
         .collect()
 }
-```
-
-(Do) Use fold/reduce for accumulating results.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use fold/reduce for accumulating results." ;
+        cs:language "rust" ;
+        cs:code """
 fn total_size(files: &[PathBuf]) -> u64 {
     files.iter()
         .filter_map(|p| fs::metadata(p).ok())
@@ -490,10 +515,12 @@ fn merge_configs(configs: &[Config]) -> Config {
     configs.iter()
         .fold(Config::default(), |acc, cfg| acc.merge(cfg))
 }
-```
-
-(Do) Chain multiple operations for complex transformations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Chain multiple operations for complex transformations." ;
+        cs:language "rust" ;
+        cs:code """
 fn process_log_entries(entries: &[LogEntry]) -> HashMap<String, Vec<&LogEntry>> {
     entries.iter()
         .filter(|e| e.level >= LogLevel::Warning)
@@ -505,10 +532,12 @@ fn process_log_entries(entries: &[LogEntry]) -> HashMap<String, Vec<&LogEntry>>
             acc
         })
 }
-```
-
-(Do) Use collect with turbofish for type-driven collection.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use collect with turbofish for type-driven collection." ;
+        cs:language "rust" ;
+        cs:code """
 // Collect into different types based on need
 let vec: Vec<_> = iter.collect();
 let set: HashSet<_> = iter.collect();
@@ -518,11 +547,12 @@ let map: HashMap<_, _> = iter.map(|x| (x.id, x)).collect();
 let results: Result<Vec<_>, _> = items.iter()
     .map(|item| process(item))
     .collect();
-```
-""" ;
-    cs:donts """
-(Don't) Use imperative loops when combinators are clearer.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use imperative loops when combinators are clearer." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Imperative style obscures intent
 fn get_names(users: &[User]) -> Vec<String> {
     let mut names = Vec::new();
@@ -541,10 +571,12 @@ fn get_names(users: &[User]) -> Vec<String> {
         .map(|u| u.name.clone())
         .collect()
 }
-```
-
-(Don't) Collect intermediate results unnecessarily.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Collect intermediate results unnecessarily." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Unnecessary allocation
 let filtered: Vec<_> = items.iter().filter(|x| x.valid).collect();
 let mapped: Vec<_> = filtered.iter().map(|x| x.value).collect();
@@ -555,10 +587,12 @@ let result: i32 = items.iter()
     .filter(|x| x.valid)
     .map(|x| x.value)
     .sum();
-```
-
-(Don't) Use for loops just to build up a Vec.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use for loops just to build up a Vec." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Manual Vec building
 let mut results = Vec::new();
 for item in items {
@@ -567,10 +601,12 @@ for item in items {
 
 // Good: Use map and collect
 let results: Vec<_> = items.iter().map(transform).collect();
-```
-
-(Don't) Nest loops when flat_map works.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Nest loops when flat_map works." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Nested loops
 let mut all_items = Vec::new();
 for container in containers {
@@ -583,8 +619,8 @@ for container in containers {
 let all_items: Vec<_> = containers.iter()
     .flat_map(|c| c.items())
     .collect();
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 5: Discriminated Unions (Sum Types)
@@ -593,16 +629,11 @@ let all_items: Vec<_> = containers.iter()
 cs:DiscriminatedUnions a cs:CodeStandard ;
     cs:name "rust/types/discriminated-unions" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Model state and variants with enums (algebraic sum types) rather than flags, inheritance, or stringly-typed values. Exhaustive pattern matching ensures all cases are handled at compile time - Rust's killer feature borrowed from ML/Haskell.
-
-**Ratings:**
-- Impact: S (exhaustive matching prevents bugs)
-- Feasibility: A (native Rust feature)
-- Idiomaticity: S (Rust's killer feature)
-- FP Purity: S (algebraic data types; Haskell-equivalent)""" ;
-    cs:dos """
-(Do) Use enums to model mutually exclusive states.
-```rust
+    cs:description """Model state and variants with enums (algebraic sum types) rather than flags, inheritance, or stringly-typed values. Exhaustive pattern matching ensures all cases are handled at compile time - Rust's killer feature borrowed from ML/Haskell.""" ;
+    cs:do [
+        cs:description "Use enums to model mutually exclusive states." ;
+        cs:language "rust" ;
+        cs:code """
 #[derive(Debug, Clone, PartialEq)]
 pub enum DepSpec {
     Workspace(String),
@@ -626,10 +657,12 @@ impl DepSpec {
         }
     }
 }
-```
-
-(Do) Use enums for state machines with compile-time guarantees.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use enums for state machines with compile-time guarantees." ;
+        cs:language "rust" ;
+        cs:code """
 enum ConnectionState {
     Disconnected,
     Connecting { attempt: u32 },
@@ -656,10 +689,12 @@ impl ConnectionState {
         }
     }
 }
-```
-
-(Do) Use enums to make invalid states unrepresentable.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use enums to make invalid states unrepresentable." ;
+        cs:language "rust" ;
+        cs:code """
 // User can be either anonymous or authenticated, never both
 enum User {
     Anonymous,
@@ -676,10 +711,12 @@ enum FieldState<T> {
     Touched { value: T, errors: Vec<ValidationError> },
     Submitted { value: T },
 }
-```
-
-(Do) Leverage exhaustive matching for safety.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Leverage exhaustive matching for safety." ;
+        cs:language "rust" ;
+        cs:code """
 fn handle_result(result: QueryResult) -> Response {
     match result {
         QueryResult::Success(data) => Response::json(data),
@@ -691,11 +728,12 @@ fn handle_result(result: QueryResult) -> Response {
         // Compiler error if we forget a variant!
     }
 }
-```
-""" ;
-    cs:donts """
-(Don't) Use boolean flags for mutually exclusive states.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use boolean flags for mutually exclusive states." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Multiple bools can have invalid combinations
 struct User {
     is_anonymous: bool,
@@ -707,10 +745,12 @@ struct User {
 struct Connection {
     state: String,  // "connected", "disconnected", typos possible
 }
-```
-
-(Don't) Use Option when you need more than two states.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use Option when you need more than two states." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Option doesn't capture "loading" vs "error" vs "empty"
 struct DataView {
     data: Option<Vec<Item>>,  // Is None loading, error, or empty?
@@ -723,10 +763,12 @@ enum DataState {
     Loaded(Vec<Item>),
     Error(String),
 }
-```
-
-(Don't) Use inheritance-like patterns with trait objects when enums suffice.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use inheritance-like patterns with trait objects when enums suffice." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Runtime dispatch when compile-time would work
 trait Shape {
     fn area(&self) -> f64;
@@ -748,10 +790,12 @@ impl Shape {
         }
     }
 }
-```
-
-(Don't) Use integers or strings as type discriminators.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use integers or strings as type discriminators." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Magic numbers
 const USER_TYPE_ADMIN: i32 = 1;
 const USER_TYPE_MEMBER: i32 = 2;
@@ -759,8 +803,8 @@ struct User { user_type: i32 }
 
 // Bad: Stringly typed
 struct Message { msg_type: String }  // "request", "response", typos!
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 6: Kleisli Composition
@@ -769,16 +813,11 @@ struct Message { msg_type: String }  // "request", "response", typos!
 cs:KleisliComposition a cs:CodeStandard ;
     cs:name "rust/functions/kleisli-composition" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Structure functions as `A -> Result<B, E>` (Kleisli arrows) for composable, chainable transformations. This enables powerful composition patterns where each step can fail, following the monadic composition style from Haskell.
-
-**Ratings:**
-- Impact: B (enables powerful composition patterns)
-- Feasibility: B (requires thinking in terms of monadic pipelines)
-- Idiomaticity: A (natural with ? and and_then)
-- FP Purity: S (direct Kleisli arrow pattern)""" ;
-    cs:dos """
-(Do) Design functions as Kleisli arrows: `A -> Result<B, E>`.
-```rust
+    cs:description """Structure functions as `A -> Result<B, E>` (Kleisli arrows) for composable, chainable transformations. This enables powerful composition patterns where each step can fail, following the monadic composition style from Haskell.""" ;
+    cs:do [
+        cs:description "Design functions as Kleisli arrows: `A -> Result<B, E>`." ;
+        cs:language "rust" ;
+        cs:code """
 // Each function is a Kleisli arrow that can be composed
 fn parse_config(input: &str) -> Result<RawConfig, ParseError> { /* ... */ }
 fn validate_config(raw: RawConfig) -> Result<ValidConfig, ValidationError> { /* ... */ }
@@ -801,10 +840,12 @@ fn process_input(s: &str) -> Result<Output, ProcessError> {
         .and_then(transform)
         .and_then(finalize)
 }
-```
-
-(Do) Use combinators to compose fallible operations.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use combinators to compose fallible operations." ;
+        cs:language "rust" ;
+        cs:code """
 impl DepSpec {
     pub fn from_value(value: &DependencyValue) -> Result<Self, ParseError> {
         match value {
@@ -821,10 +862,12 @@ impl DepSpec {
         }
     }
 }
-```
-
-(Do) Create helper traits for method chaining when needed.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Create helper traits for method chaining when needed." ;
+        cs:language "rust" ;
+        cs:code """
 trait ResultExt<T, E> {
     fn and_try<U, F>(self, f: F) -> Result<U, E>
     where
@@ -845,10 +888,12 @@ let result = input
     .and_try(step1)
     .and_try(step2)
     .and_try(step3);
-```
-
-(Do) Use the pipe pattern for readability.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use the pipe pattern for readability." ;
+        cs:language "rust" ;
+        cs:code """
 // With a pipe trait or tap crate
 trait Pipe: Sized {
     fn pipe<F, R>(self, f: F) -> R where F: FnOnce(Self) -> R {
@@ -862,11 +907,12 @@ let result = input
     .pipe(parse)
     .and_then(|x| x.pipe(validate))
     .and_then(|x| x.pipe(transform));
-```
-""" ;
-    cs:donts """
-(Don't) Mix side effects into pure transformation chains.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Mix side effects into pure transformation chains." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Side effects hidden in chain
 fn process(input: &str) -> Result<Output, Error> {
     parse(input)
@@ -886,10 +932,12 @@ fn process(input: &str) -> Result<Output, Error> {
     let validated = validate(parsed)?;
     transform(validated)
 }
-```
-
-(Don't) Break the chain with early returns when and_then works.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Break the chain with early returns when and_then works." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Breaks the monadic flow
 fn process(input: &str) -> Result<Output, Error> {
     let parsed = parse(input)?;
@@ -911,17 +959,19 @@ fn process(input: &str) -> Result<Output, Error> {
         .and_then(|t| (!t.is_empty()).then_some(t).ok_or(Error::Empty))
         .map(finalize)
 }
-```
-
-(Don't) Use unwrap in the middle of a chain.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use unwrap in the middle of a chain." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Panics break the monadic abstraction
 let result = items.iter()
     .map(|x| parse(x).unwrap())  // Panic!
     .filter(|x| x.is_valid())
     .collect();
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 7: Typestate Guards (Parse, Don't Validate)
@@ -930,16 +980,11 @@ let result = items.iter()
 cs:TypestateGuards a cs:CodeStandard ;
     cs:name "rust/validation/typestate-guards" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Use constructor validation to ensure only valid states can exist. Follow the 'parse, don't validate' principle: transform unvalidated data into validated types at system boundaries, making invalid states unrepresentable.
-
-**Ratings:**
-- Impact: S (invalid states become unrepresentable)
-- Feasibility: B (requires upfront design thinking)
-- Idiomaticity: A (recommended Rust pattern)
-- FP Purity: A (Haskell-inspired 'make illegal states unrepresentable')""" ;
-    cs:dos """
-(Do) Validate in constructors to ensure type invariants.
-```rust
+    cs:description """Use constructor validation to ensure only valid states can exist. Follow the 'parse, don't validate' principle: transform unvalidated data into validated types at system boundaries, making invalid states unrepresentable.""" ;
+    cs:do [
+        cs:description "Validate in constructors to ensure type invariants." ;
+        cs:language "rust" ;
+        cs:code """
 impl Manifest {
     pub fn from_path(path: &Path) -> Result<Self, ManifestError> {
         let content = fs::read_to_string(path)
@@ -962,10 +1007,12 @@ impl Manifest {
         }
     }
 }
-```
-
-(Do) Use the typestate pattern for compile-time state enforcement.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use the typestate pattern for compile-time state enforcement." ;
+        cs:language "rust" ;
+        cs:code """
 // States as zero-sized types
 struct Draft;
 struct Published;
@@ -1001,10 +1048,12 @@ impl Article<Published> {
 // Compile-time enforcement:
 // article_draft.view();  // Error: method not found
 // article_published.publish();  // Error: method not found
-```
-
-(Do) Parse into validated types at system boundaries.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Parse into validated types at system boundaries." ;
+        cs:language "rust" ;
+        cs:code """
 // Raw input from external source
 struct RawUserInput {
     email: String,
@@ -1036,10 +1085,12 @@ impl Email {
         }
     }
 }
-```
-
-(Do) Make the validated state obvious in function signatures.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Make the validated state obvious in function signatures." ;
+        cs:language "rust" ;
+        cs:code """
 // Functions that require validation communicate it via types
 fn send_email(to: &Email, subject: &str, body: &str) -> Result<(), SendError> {
     // Email is already validated - no need to check again
@@ -1048,11 +1099,12 @@ fn send_email(to: &Email, subject: &str, body: &str) -> Result<(), SendError> {
 fn create_account(user: ValidatedUser) -> Result<Account, AccountError> {
     // All fields are pre-validated
 }
-```
-""" ;
-    cs:donts """
-(Don't) Scatter validation logic throughout the codebase.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Scatter validation logic throughout the codebase." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Validation repeated everywhere
 fn send_email(to: &str, subject: &str, body: &str) -> Result<(), Error> {
     if !to.contains('@') {
@@ -1067,10 +1119,12 @@ fn save_user(email: &str) -> Result<(), Error> {
     }
     // ... save logic
 }
-```
-
-(Don't) Allow construction of invalid objects.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Allow construction of invalid objects." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Public fields allow invalid state
 pub struct Email {
     pub address: String,  // Anyone can set invalid value
@@ -1082,10 +1136,12 @@ impl User {
         Self { email, age }  // Could be invalid!
     }
 }
-```
-
-(Don't) Use validation functions that return bool.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use validation functions that return bool." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Caller can ignore the result
 fn is_valid_email(s: &str) -> bool {
     s.contains('@')
@@ -1099,10 +1155,12 @@ if is_valid_email(&email) {
 // Good: Parsing forces handling
 fn parse_email(s: &str) -> Result<Email, ValidationError>
 // Caller must handle the Result
-```
-
-(Don't) Re-validate already-validated data.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Re-validate already-validated data." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Redundant validation
 fn process(user: ValidatedUser) -> Result<(), Error> {
     // ValidatedUser is already valid by construction!
@@ -1111,8 +1169,8 @@ fn process(user: ValidatedUser) -> Result<(), Error> {
     }
     // ...
 }
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 8: Small, Composable Traits
@@ -1121,16 +1179,11 @@ fn process(user: ValidatedUser) -> Result<(), Error> {
 cs:SmallComposableTraits a cs:CodeStandard ;
     cs:name "rust/traits/small-composable" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Prefer small, focused traits that compose well over large monolithic interfaces. This Haskell typeclass-inspired approach enables better abstraction, easier testing, and more flexible code reuse.
-
-**Ratings:**
-- Impact: A (better abstraction, easier testing)
-- Feasibility: B (requires careful API design)
-- Idiomaticity: S (Rust's trait system shines here)
-- FP Purity: A (typeclass-inspired composition)""" ;
-    cs:dos """
-(Do) Design small, single-purpose traits.
-```rust
+    cs:description """Prefer small, focused traits that compose well over large monolithic interfaces. This Haskell typeclass-inspired approach enables better abstraction, easier testing, and more flexible code reuse.""" ;
+    cs:do [
+        cs:description "Design small, single-purpose traits." ;
+        cs:language "rust" ;
+        cs:code """
 /// Can be resolved from a prefixed form to a full URI
 trait Resolvable {
     fn resolve(&self, prefix_map: &PrefixMap) -> String;
@@ -1152,10 +1205,12 @@ trait Loadable: Sized {
     type Error;
     fn load(path: &Path) -> Result<Self, Self::Error>;
 }
-```
-
-(Do) Compose traits using supertraits and bounds.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Compose traits using supertraits and bounds." ;
+        cs:language "rust" ;
+        cs:code """
 // Compose small traits into larger capabilities
 trait UriHandler: Resolvable + Compactable {}
 
@@ -1166,10 +1221,12 @@ impl<T: Resolvable + Compactable> UriHandler for T {}
 fn process_uri<T: Resolvable + Display>(uri: &T, map: &PrefixMap) -> String {
     format!("{} -> {}", uri, uri.resolve(map))
 }
-```
-
-(Do) Use extension traits to add methods to existing types.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use extension traits to add methods to existing types." ;
+        cs:language "rust" ;
+        cs:code """
 trait ResultExt<T, E> {
     fn context(self, msg: &str) -> Result<T, ContextError<E>>;
     fn with_context<F: FnOnce() -> String>(self, f: F) -> Result<T, ContextError<E>>;
@@ -1188,10 +1245,12 @@ impl<T, E> ResultExt<T, E> for Result<T, E> {
 // Usage
 let data = fs::read_to_string(path)
     .context("failed to read config")?;
-```
-
-(Do) Implement standard library traits for interoperability.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Implement standard library traits for interoperability." ;
+        cs:language "rust" ;
+        cs:code """
 impl Default for SemStore {
     fn default() -> Self {
         Self::new().expect("Failed to create default SemStore")
@@ -1211,11 +1270,12 @@ impl FromStr for Version {
         // parsing logic
     }
 }
-```
-""" ;
-    cs:donts """
-(Don't) Create large, monolithic traits.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Create large, monolithic traits." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Too many responsibilities
 trait Repository {
     fn connect(&mut self) -> Result<(), Error>;
@@ -1230,10 +1290,12 @@ trait Repository {
     fn execute_query(&self, query: &str) -> Result<QueryResult, Error>;
     // ... 20 more methods
 }
-```
-
-(Don't) Use trait objects when generics suffice.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use trait objects when generics suffice." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Unnecessary dynamic dispatch
 fn process(items: &[Box<dyn Processable>]) {
     for item in items {
@@ -1247,10 +1309,12 @@ fn process<T: Processable>(items: &[T]) {
         item.process();
     }
 }
-```
-
-(Don't) Require unused trait methods via blanket requirements.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Require unused trait methods via blanket requirements." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Forces implementers to provide unused methods
 trait DataStore: Connect + Query + Mutate + Transaction + Cache + Log {
     // Most implementers don't need all of these
@@ -1260,10 +1324,12 @@ trait DataStore: Connect + Query + Mutate + Transaction + Cache + Log {
 fn process<T: Query + Mutate>(store: &mut T) {
     // Only requires the capabilities actually used
 }
-```
-
-(Don't) Use associated types when generic parameters work better.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use associated types when generic parameters work better." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Can only have one implementation per type
 trait Container {
     type Item;
@@ -1275,8 +1341,8 @@ trait Container<T> {
     fn get(&self) -> &T;
 }
 // Now Vec<i32> can be Container<i32> AND Container<String> if needed
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 9: Explicit Absence (Option Handling)
@@ -1285,16 +1351,11 @@ trait Container<T> {
 cs:ExplicitAbsence a cs:CodeStandard ;
     cs:name "rust/option/explicit-absence" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Use Option explicitly and idiomatically; prefer Option<T> combinators (map, and_then, unwrap_or, ok_or) over null-like patterns. Option is Rust's Maybe monad - use it as such.
-
-**Ratings:**
-- Impact: A (eliminates null-related bugs)
-- Feasibility: S (Rust enforces this)
-- Idiomaticity: S (fundamental Rust pattern)
-- FP Purity: S (Maybe monad equivalent)""" ;
-    cs:dos """
-(Do) Use Option combinators for clean transformations.
-```rust
+    cs:description """Use Option explicitly and idiomatically; prefer Option<T> combinators (map, and_then, unwrap_or, ok_or) over null-like patterns. Option is Rust's Maybe monad - use it as such.""" ;
+    cs:do [
+        cs:description "Use Option combinators for clean transformations." ;
+        cs:language "rust" ;
+        cs:code """
 impl Manifest {
     pub fn display_name(&self) -> Option<String> {
         self.workspace.as_ref()
@@ -1310,10 +1371,12 @@ impl Manifest {
         self.workspace.as_ref().map(|w| w.members.clone())
     }
 }
-```
-
-(Do) Use unwrap_or and unwrap_or_else for defaults.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use unwrap_or and unwrap_or_else for defaults." ;
+        cs:language "rust" ;
+        cs:code """
 fn get_config_value(key: &str) -> String {
     config.get(key)
         .cloned()
@@ -1326,10 +1389,12 @@ fn get_timeout() -> Duration {
         .and_then(|s| s.parse().ok())
         .unwrap_or(Duration::from_secs(30))
 }
-```
-
-(Do) Use ok_or to convert Option to Result.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use ok_or to convert Option to Result." ;
+        cs:language "rust" ;
+        cs:code """
 fn find_package(name: &str) -> Result<&Package, PackageError> {
     packages.get(name)
         .ok_or_else(|| PackageError::NotFound(name.to_string()))
@@ -1339,10 +1404,12 @@ fn get_required_field<'a>(map: &'a HashMap<String, Value>, key: &str) -> Result<
     map.get(key)
         .ok_or(ConfigError::MissingField(key.to_string()))
 }
-```
-
-(Do) Use filter and filter_map for conditional processing.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use filter and filter_map for conditional processing." ;
+        cs:language "rust" ;
+        cs:code """
 fn find_active_user(id: UserId) -> Option<User> {
     users.get(&id).filter(|u| u.is_active)
 }
@@ -1352,20 +1419,23 @@ fn get_valid_entries(entries: &[Entry]) -> Vec<&Entry> {
         .filter(|e| e.is_valid())
         .collect()
 }
-```
-
-(Do) Use the ? operator with Option in functions returning Option.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use the ? operator with Option in functions returning Option." ;
+        cs:language "rust" ;
+        cs:code """
 fn get_nested_value(data: &Data) -> Option<&str> {
     let section = data.sections.get("main")?;
     let item = section.items.first()?;
     item.value.as_deref()
 }
-```
-""" ;
-    cs:donts """
-(Don't) Use sentinel values instead of Option.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Use sentinel values instead of Option." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Magic values
 fn find_index(items: &[Item], target: &Item) -> i32 {
     // Returns -1 if not found - caller might forget to check!
@@ -1376,10 +1446,12 @@ fn find_index(items: &[Item], target: &Item) -> i32 {
 fn find_index(items: &[Item], target: &Item) -> Option<usize> {
     items.iter().position(|i| i == target)
 }
-```
-
-(Don't) Overuse unwrap() or expect() outside of tests.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Overuse unwrap() or expect() outside of tests." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Panics on None
 let user = users.get(id).unwrap();
 let name = user.name.as_ref().unwrap();
@@ -1387,10 +1459,12 @@ let name = user.name.as_ref().unwrap();
 // Good: Handle absence explicitly
 let user = users.get(id).ok_or(UserError::NotFound(id))?;
 let name = user.name.as_deref().unwrap_or("Anonymous");
-```
-
-(Don't) Check is_some/is_none then unwrap.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Check is_some/is_none then unwrap." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Redundant check
 if value.is_some() {
     let v = value.unwrap();  // We just checked!
@@ -1404,10 +1478,12 @@ if let Some(v) = value {
 
 // Or even better for side effects
 value.map(process);
-```
-
-(Don't) Create deeply nested Option chains without combinators.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Create deeply nested Option chains without combinators." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Nested matching
 match outer {
     Some(o) => match o.inner {
@@ -1425,8 +1501,8 @@ outer
     .and_then(|o| o.inner)
     .and_then(|i| i.value)
     .map(transform)
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 10: Property-Based Testing
@@ -1435,16 +1511,11 @@ outer
 cs:PropertyBasedTesting a cs:CodeStandard ;
     cs:name "rust/testing/property-based" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Complement unit tests with property-based testing to verify invariants across many generated inputs. This QuickCheck-inspired approach catches edge cases that example-based tests miss.
-
-**Ratings:**
-- Impact: A (catches edge cases unit tests miss)
-- Feasibility: B (requires proptest/quickcheck; learning curve)
-- Idiomaticity: A (growing Rust practice)
-- FP Purity: S (QuickCheck heritage; declarative testing)""" ;
-    cs:dos """
-(Do) Use proptest for property-based testing.
-```rust
+    cs:description """Complement unit tests with property-based testing to verify invariants across many generated inputs. This QuickCheck-inspired approach catches edge cases that example-based tests miss.""" ;
+    cs:do [
+        cs:description "Use proptest for property-based testing." ;
+        cs:language "rust" ;
+        cs:code """
 use proptest::prelude::*;
 
 proptest! {
@@ -1467,10 +1538,12 @@ proptest! {
         }
     }
 }
-```
-
-(Do) Test algebraic properties (identity, associativity, commutativity).
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Test algebraic properties (identity, associativity, commutativity)." ;
+        cs:language "rust" ;
+        cs:code """
 proptest! {
     #[test]
     fn merge_associative(a: Config, b: Config, c: Config) {
@@ -1487,10 +1560,12 @@ proptest! {
         assert_eq!(merged, config);
     }
 }
-```
-
-(Do) Test invariants that should hold for all valid inputs.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Test invariants that should hold for all valid inputs." ;
+        cs:language "rust" ;
+        cs:code """
 proptest! {
     #[test]
     fn validated_email_contains_at(s in ".+@.+\\..+") {
@@ -1511,10 +1586,12 @@ proptest! {
         }
     }
 }
-```
-
-(Do) Use custom strategies for domain-specific types.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use custom strategies for domain-specific types." ;
+        cs:language "rust" ;
+        cs:code """
 fn valid_package_name() -> impl Strategy<Value = String> {
     "[a-z][a-z0-9-]{0,62}[a-z0-9]?"
         .prop_filter("Must not have consecutive hyphens", |s| !s.contains("--"))
@@ -1531,11 +1608,12 @@ proptest! {
         assert!(PackageName::new(&name).is_ok());
     }
 }
-```
-""" ;
-    cs:donts """
-(Don't) Only write example-based unit tests for complex logic.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Only write example-based unit tests for complex logic." ;
+        cs:language "rust" ;
+        cs:code """
 // Incomplete: Only tests a few examples
 #[test]
 fn test_merge() {
@@ -1545,10 +1623,12 @@ fn test_merge() {
     assert_eq!(merged.timeout, 20);
     // What about edge cases? Overflow? Default values?
 }
-```
-
-(Don't) Ignore test failures without understanding the counterexample.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Ignore test failures without understanding the counterexample." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Ignoring failures
 proptest! {
     #[test]
@@ -1557,10 +1637,12 @@ proptest! {
         // ...
     }
 }
-```
-
-(Don't) Write properties that are too weak or tautological.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Write properties that are too weak or tautological." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: This always passes, tests nothing useful
 proptest! {
     #[test]
@@ -1577,10 +1659,12 @@ proptest! {
         assert_eq!(add(a, b), a + b);  // Just restates the implementation
     }
 }
-```
-
-(Don't) Generate invalid inputs without proper filtering.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Generate invalid inputs without proper filtering." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Generates invalid UTF-8 and panics
 proptest! {
     #[test]
@@ -1596,8 +1680,8 @@ proptest! {
         // ...
     }
 }
-```
-""" .
+    """
+    ] .
 
 # =============================================================================
 # Standard 11: TDD Red-Green-Refactor
@@ -1606,16 +1690,11 @@ proptest! {
 cs:TDDRedGreenRefactor a cs:CodeStandard ;
     cs:name "rust/testing/tdd-red-green-refactor" ;
     cs:hasCategory cs:RustCategory ;
-    cs:description """Follow the strict TDD cycle: write a failing test first (red), implement minimally to pass (green), then refactor. This discipline ensures testability, prevents regression, and drives better design.
-
-**Ratings:**
-- Impact: S (ensures testability, prevents regression)
-- Feasibility: A (Rust's cargo test makes this easy)
-- Idiomaticity: A (industry best practice)
-- FP Purity: B (supports referential transparency goals)""" ;
-    cs:dos """
-(Do) Write the test first, watch it fail.
-```rust
+    cs:description """Follow the strict TDD cycle: write a failing test first (red), implement minimally to pass (green), then refactor. This discipline ensures testability, prevents regression, and drives better design.""" ;
+    cs:do [
+        cs:description "Write the test first, watch it fail." ;
+        cs:language "rust" ;
+        cs:code """
 // Step 1: RED - Write failing test
 #[cfg(test)]
 mod tests {
@@ -1631,10 +1710,12 @@ mod tests {
 }
 
 // At this point: cargo test fails - Version doesn't exist yet!
-```
-
-(Do) Implement the minimum code to pass.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Implement the minimum code to pass." ;
+        cs:language "rust" ;
+        cs:code """
 // Step 2: GREEN - Minimal implementation
 pub struct Version {
     pub major: u32,
@@ -1657,10 +1738,12 @@ impl Version {
 }
 
 // cargo test passes!
-```
-
-(Do) Refactor while keeping tests green.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Refactor while keeping tests green." ;
+        cs:language "rust" ;
+        cs:code """
 // Step 3: REFACTOR - Improve design
 impl Version {
     pub fn parse(s: &str) -> Result<Self, ParseError> {
@@ -1685,10 +1768,12 @@ impl Version {
 }
 
 // Tests still pass after refactoring!
-```
-
-(Do) Add tests for edge cases incrementally.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Add tests for edge cases incrementally." ;
+        cs:language "rust" ;
+        cs:code """
 #[test]
 fn parse_rejects_empty_string() {
     assert!(Version::parse("").is_err());
@@ -1709,10 +1794,12 @@ fn parse_handles_leading_zeros() {
     let v = Version::parse("01.02.03").unwrap();
     assert_eq!(v.major, 1);  // Decide: allow or reject?
 }
-```
-
-(Do) Use test modules colocated with implementation.
-```rust
+    """
+    ] ;
+    cs:do [
+        cs:description "Use test modules colocated with implementation." ;
+        cs:language "rust" ;
+        cs:code """
 // src/version.rs
 pub struct Version { /* ... */ }
 
@@ -1728,21 +1815,24 @@ mod tests {
     #[test]
     fn test_parse() { /* ... */ }
 }
-```
-""" ;
-    cs:donts """
-(Don't) Write implementation before tests.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Write implementation before tests." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Implementation without tests
 pub fn complex_algorithm(input: &str) -> Result<Output, Error> {
     // 200 lines of complex logic
     // No tests to verify correctness
     // No tests to prevent regression
 }
-```
-
-(Don't) Write tests that pass trivially or test nothing.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Write tests that pass trivially or test nothing." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Test that always passes
 #[test]
 fn useless_test() {
@@ -1754,10 +1844,12 @@ fn useless_test() {
 fn test_without_assertions() {
     let _ = Version::parse("1.0.0");  // No assertions!
 }
-```
-
-(Don't) Skip the refactor step.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Skip the refactor step." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: "It works, ship it!"
 impl Version {
     pub fn parse(s: &str) -> Result<Self, ParseError> {
@@ -1772,20 +1864,24 @@ impl Version {
         Ok(Self { major: a.unwrap(), minor: b.unwrap(), patch: c.unwrap() })
     }
 }
-```
-
-(Don't) Write tests after the fact that just confirm current behavior.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Write tests after the fact that just confirm current behavior." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: "Characterization tests" without understanding intent
 #[test]
 fn test_weird_behavior() {
     // I don't know why it returns 42, but it does, so test it
     assert_eq!(mysterious_function("input"), 42);
 }
-```
-
-(Don't) Test private implementation details.
-```rust
+    """
+    ] ;
+    cs:dont [
+        cs:description "Test private implementation details." ;
+        cs:language "rust" ;
+        cs:code """
 // Bad: Testing internals that may change
 #[test]
 fn test_internal_cache_structure() {
@@ -1802,5 +1898,5 @@ fn test_caching_behavior() {
     let result2 = obj.expensive_operation();  // Should be cached
     assert_eq!(result1, result2);
 }
-```
-""" .
+    """
+    ] .