wip

Author: wanguardd

module/move/benchkit/Cargo.toml

@@ -61,8 +61,32 @@ criterion_compat = [ "enabled", "dep:criterion" ]  # Compatibility layer
 no_std = []
 use_alloc = [ "no_std" ]
 
+# In workspace context, use:
+# [lints]
+# workspace = true
+
+# For standalone development, define lints inline:
+[lints.rust]
+rust_2018_idioms = { level = "warn", priority = -1 }
+future_incompatible = { level = "warn", priority = -1 }
+missing_docs = "warn"
+missing_debug_implementations = "warn"
+unsafe-code = "deny"
+
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+undocumented_unsafe_blocks = "deny"
+std_instead_of_core = "warn"
+doc_include_without_cfg = "warn"
+missing_inline_in_public_items = "allow"
+
 [dependencies]
 # Core dependencies - always available
+# Note: In workspace context, use:
+# error_tools = { workspace = true, features = [ "enabled" ] }
+# mod_interface = { workspace = true }
+# For standalone development:
+error_tools = { git = "https://github.com/Wandalen/wTools", branch = "alpha", features = [ "enabled" ] }
 
 # Feature-gated dependencies  
 pulldown-cmark = { version = "0.10", optional = true }
@@ -74,6 +98,10 @@ criterion = { version = "0.5", optional = true }
 chrono = { version = "0.4", features = ["serde"], optional = true }
 
 [dev-dependencies]
+# In workspace context, use:
+# test_tools = { workspace = true }
+# tempfile = { workspace = true }
+# For standalone development:
 tempfile = "3.0"
 
 # Examples will be added as implementation progresses

module/move/benchkit/readme.md

@@ -29,26 +29,30 @@ fn main() {
 ```rust
 use benchkit::prelude::*;
 
+fn generate_random_vec(size: usize) -> Vec<u32> {
+    (0..size).map(|x| x as u32).collect()
+}
+
 fn main() {
     let mut comparison = ComparativeAnalysis::new("sorting_algorithms");
 
     // Compare different sorting approaches
     for size in [100, 1000, 10000] {
         let data = generate_random_vec(size);
 
-        comparison.add_variant(&format!("std_sort_{}", size), {
+        comparison = comparison.algorithm(&format!("std_sort_{}", size), {
             let mut d = data.clone();
-            move || d.sort()
+            move || { d.sort(); }
         });
 
-        comparison.add_variant(&format!("unstable_sort_{}", size), {
+        comparison = comparison.algorithm(&format!("unstable_sort_{}", size), {
             let mut d = data.clone();
-            move || d.sort_unstable()  
+            move || { d.sort_unstable(); }
         });
     }
 
     let report = comparison.run();
-    report.print_summary();
+    println!("Fastest: {:?}", report.fastest());
 }
 ```
 
@@ -135,11 +139,22 @@ Perfect for ad-hoc performance analysis:
 ```rust
 use benchkit::prelude::*;
 
+fn old_algorithm(data: &[u32]) -> u32 {
+    data.iter().sum()
+}
+
+fn new_algorithm(data: &[u32]) -> u32 {
+    data.iter().fold(0, |acc, x| acc + x)
+}
+
+let data = vec![1, 2, 3, 4, 5];
+
 // Quick check - is this optimization working?
 let before = bench_once(|| old_algorithm(&data));
 let after = bench_once(|| new_algorithm(&data));
 
-println!("Improvement: {:.1}%", before.compare(&after).improvement());
+let comparison = before.compare(&after);
+println!("Improvement: {:.1}%", comparison.improvement_percentage);
 ```
 
 ### Pattern 2: Comprehensive Analysis
@@ -149,26 +164,38 @@ For thorough performance characterization:
 ```rust
 use benchkit::prelude::*;
 
+fn generate_test_data(size: usize) -> Vec<u32> {
+    (0..size).map(|x| x as u32).collect()
+}
+
+fn run_algorithm(algorithm: &str, data: &[u32]) -> u32 {
+    match algorithm {
+        "baseline" => data.iter().sum(),
+        "optimized" => data.iter().fold(0, |acc, x| acc + x),
+        "simd" => data.iter().sum::<u32>(),
+        _ => 0,
+    }
+}
+
 fn analyze_performance() {
     let mut suite = BenchmarkSuite::new("comprehensive_analysis");
 
     // Test across multiple dimensions
     for size in [10, 100, 1000, 10000] {
         for algorithm in ["baseline", "optimized", "simd"] {
             let data = generate_test_data(size);
-            suite.benchmark(&format!("{}_size_{}", algorithm, size), || {
-                run_algorithm(algorithm, &data)
+            let alg = algorithm.to_string();
+            suite.benchmark(&format!("{}_size_{}", algorithm, size), move || {
+                run_algorithm(&alg, &data);
             });
         }
     }
 
     let analysis = suite.run_analysis();
 
     // Generate comprehensive report
-    analysis.generate_report()
-            .with_scaling_analysis()
-            .with_recommendations()
-            .save_markdown("performance_analysis.md");
+    let report = analysis.generate_markdown_report();
+    println!("{}", report.generate());
 }
 ```
 

module/move/benchkit/src/lib.rs

@@ -20,10 +20,10 @@
 //! // Simple timing measurement
 //! let result = bench_function("my_operation", || {
 //!     // Your code here
-//!     std::thread::sleep(std::time::Duration::from_millis(1));
+//!     std::hint::black_box(42 + 42);
 //! });
 //! 
-//! println!("Average time: {:.2?}", result.mean_time());
+//! println!("Average time: {:?}", result.mean_time());
 //! ```
 //!
 //! ## Features

module/move/benchkit/src/reporting.rs

@@ -24,7 +24,7 @@ impl MarkdownUpdater {
   }
 
   /// Update the section with new content
-  pub fn update_section(&self, content: &str) -> Result<(), std::io::Error> {
+  pub fn update_section(&self, content: &str) -> error_tools::Result<()> {
     // Read existing file or create empty content
     let existing_content = if self.file_path.exists() {
       std::fs::read_to_string(&self.file_path)?
@@ -251,7 +251,7 @@ impl ReportGenerator {
   }
 
   /// Update markdown file section with report
-  pub fn update_markdown_file(&self, file_path: impl AsRef<Path>, section_name: &str) -> Result<(), std::io::Error> {
+  pub fn update_markdown_file(&self, file_path: impl AsRef<Path>, section_name: &str) -> error_tools::Result<()> {
     let updater = MarkdownUpdater::new(file_path, section_name);
     let content = self.generate_comprehensive_report();
     updater.update_section(&content)
@@ -300,7 +300,7 @@ pub mod quick {
     file_path: impl AsRef<Path>,
     section_name: &str,
     title: &str
-  ) -> Result<(), std::io::Error> {
+  ) -> error_tools::Result<()> {
     let generator = ReportGenerator::new(title, results.clone());
     generator.update_markdown_file(file_path, section_name)
   }

module/move/benchkit/src/suite.rs

@@ -126,7 +126,7 @@ impl SuiteResults {
   }
 
   /// Save results as new baseline
-  pub fn save_as_baseline(&self, _baseline_file: impl AsRef<std::path::Path>) -> Result<(), std::io::Error> {
+  pub fn save_as_baseline(&self, _baseline_file: impl AsRef<std::path::Path>) -> error_tools::Result<()> {
     // TODO: Implement saving to JSON/TOML file
     // For now, just succeed
     Ok(())
@@ -236,17 +236,18 @@ impl MarkdownReport {
     &self, 
     file_path: impl AsRef<std::path::Path>, 
     section_name: &str
-  ) -> Result<(), Box<dyn std::error::Error>> {
+  ) -> error_tools::Result<()> {
     // TODO: Implement markdown file section updating
     // This would parse existing markdown, find section, and replace content
     println!("Would update {} section in {:?}", section_name, file_path.as_ref());
     Ok(())
   }
 
   /// Save report to file
-  pub fn save(&self, file_path: impl AsRef<std::path::Path>) -> Result<(), std::io::Error> {
+  pub fn save(&self, file_path: impl AsRef<std::path::Path>) -> error_tools::Result<()> {
     let content = self.generate();
-    std::fs::write(file_path, content)
+    std::fs::write(file_path, content)?;
+    Ok(())
   }
 }