ruchy 4.2.0

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// STDLIB-005 Example: Find Duplicate Files
//
// Demonstrates walk_parallel() + compute_hash() composition
// Use case: Find duplicate files in a directory (like rclean)
// Perfect composable API design

use std::fs;
use tempfile::TempDir;

fn main() {
    println!("🔍 Duplicate File Finder (Ruchy + rclean pattern)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    // Create temp directory with duplicate files
    let temp = TempDir::new().expect("Failed to create temp dir");

    // Create some duplicate files
    fs::write(temp.path().join("doc1.txt"), "Same content").unwrap();
    fs::write(temp.path().join("doc2.txt"), "Same content").unwrap();
    fs::write(temp.path().join("doc3.txt"), "Same content").unwrap();
    fs::write(temp.path().join("unique1.txt"), "Unique content A").unwrap();
    fs::write(temp.path().join("unique2.txt"), "Unique content B").unwrap();

    println!("Created test directory: {}", temp.path().display());
    println!("  3 duplicate files (doc1.txt, doc2.txt, doc3.txt)");
    println!("  2 unique files (unique1.txt, unique2.txt)");
    println!();

    // Ruchy code to find duplicates
    let code = format!(
        r#"
        # Step 1: Walk directory in parallel and compute hashes
        let dir = "{}"
        println("Scanning directory: {{}}", dir)

        let entries = walk_parallel(dir)
        let files = entries.filter(fn(e) {{ e.is_file }})

        println("Found {{}} files", files.len())
        println()

        # Step 2: Compute hashes for all files
        let with_hashes = files.map(fn(e) {{
            let hash = compute_hash(e.path)
            Object.merge(e, {{ hash: hash }})
        }})

        # Step 3: Group by hash to find duplicates
        # For now, we'll do this manually since we don't have group_by yet
        println("Files by hash:")
        let _ = with_hashes.map(fn(f) {{
            println("  {{}} → {{}}", f.name, f.hash)
        }})
        println()

        # Step 4: Find files with matching hashes
        # NOTE: This is a simplified version - proper duplicate detection would use
        # group_by() or mutable closure capture (not yet supported in Ruchy)

        # For demonstration, just show first duplicate group
        let first_hash = with_hashes.first().hash
        let matches = with_hashes.filter(fn(f) {{
            f.hash == first_hash
        }})

        if matches.len() > 1 {{
            println("🔍 Found {{}} files with hash {{}}", matches.len(), first_hash)
            let _ = matches.map(fn(m) {{
                println("    - {{}}", m.name)
            }})
            println()
        }}

        println("✅ Duplicate scan complete (showing first duplicate group only)!")
    "#,
        temp.path().display()
    );

    // Run via ruchy interpreter
    let output = std::process::Command::new("cargo")
        .args(["run", "--release", "--bin", "ruchy", "--", "-e", &code])
        .output()
        .expect("Failed to execute ruchy");

    if output.status.success() {
        print!("{}", String::from_utf8_lossy(&output.stdout));
    } else {
        eprintln!("Error: {}", String::from_utf8_lossy(&output.stderr));
        std::process::exit(1);
    }

    println!();
    println!("💡 This demonstrates the perfect composable API:");
    println!("   walk_parallel() does parallel I/O");
    println!("   compute_hash() enables duplicate detection");
    println!("   Users compose with .filter(), .map(), array methods");
}