Struct ConfigurableShrinker 

pub struct ConfigurableShrinker<T> { /* private fields */ }

Configurable shrinker with search strategy control

Allows choosing between breadth-first and depth-first search strategies when exploring the shrink space.

Examples

use protest_extras::shrinking::{ConfigurableShrinker, ShrinkStrategy};

let value = vec![1, 2, 3, 4, 5];

// Depth-first: aggressive shrinking
let shrinker = ConfigurableShrinker::new(value.clone(), ShrinkStrategy::DepthFirst);
let depth_result = shrinker.find_minimal(|v| v.len() >= 2);

// Breadth-first: explore more evenly
let shrinker = ConfigurableShrinker::new(value, ShrinkStrategy::BreadthFirst);
let breadth_result = shrinker.find_minimal(|v| v.len() >= 2);

assert!(depth_result.len() >= 2);
assert!(breadth_result.len() >= 2);

Implementations

impl<T: Clone> ConfigurableShrinker<T>

pub fn new(value: T, strategy: ShrinkStrategy) -> Self

Create a new configurable shrinker

Examples found in repository

examples/advanced_shrinking.rs (line 120)

fn example_3_configurable_shrinker_dfs() {
    println!("Example 3: ConfigurableShrinker - Depth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (DFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nDepth-First Strategy:");
    println!("  - Follows the first successful shrink immediately");
    println!("  - Goes deep before exploring alternatives");
    println!("  - Fast but may not find the absolute minimal");
    println!("  - Good when any reasonably small counterexample is sufficient");
}

/// Example 4: ConfigurableShrinker with Breadth-First Search
fn example_4_configurable_shrinker_bfs() {
    println!("Example 4: ConfigurableShrinker - Breadth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (BFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nBreadth-First Strategy:");
    println!("  - Explores all shrinks at current depth before going deeper");
    println!("  - More thorough exploration");
    println!("  - Finds the truly minimal counterexample");
    println!("  - Slower but more comprehensive");
}

/// Example 5: Comparing all strategies on the same problem
fn example_5_comparing_strategies() {
    println!("Example 5: Strategy Comparison");
    println!("{}", "-".repeat(60));

    // Problem: Find minimal subset where sum of squares > 500
    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    let sum_of_squares = |v: &Vec<i32>| v.iter().map(|x| x * x).sum::<i32>();

    println!("Original vector: {:?}", original);
    println!("Sum of squares: {}", sum_of_squares(&original));
    println!("\nFinding minimal subset where sum of squares > 500\n");

    // Strategy 1: Cascading (manual exploration)
    let cascading = CascadingShrinker::new(original.clone());
    let candidates: Vec<_> = cascading.shrink().collect();
    let cascading_result = candidates
        .iter()
        .filter(|v| sum_of_squares(v) > 500)
        .min_by_key(|v| v.len())
        .cloned();

    if let Some(result) = cascading_result {
        println!("1. CascadingShrinker:");
        println!("   Result: {:?}", result);
        println!("   Length: {}", result.len());
        println!("   Sum of squares: {}", sum_of_squares(&result));
        println!("   Total candidates explored: {}", candidates.len());
    }

    // Strategy 2: Guided
    let guided = GuidedShrinker::new(original.clone());
    let (guided_result, guided_iterations) =
        guided.find_minimal_with_stats(|v| sum_of_squares(v) > 500);

    println!("\n2. GuidedShrinker:");
    println!("   Result: {:?}", guided_result);
    println!("   Length: {}", guided_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&guided_result));
    println!("   Iterations: {}", guided_iterations);

    // Strategy 3: DFS
    let dfs =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);
    let dfs_result = dfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n3. ConfigurableShrinker (DFS):");
    println!("   Result: {:?}", dfs_result);
    println!("   Length: {}", dfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&dfs_result));

    // Strategy 4: BFS
    let bfs = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);
    let bfs_result = bfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n4. ConfigurableShrinker (BFS):");
    println!("   Result: {:?}", bfs_result);
    println!("   Length: {}", bfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&bfs_result));

    println!("\n{}", "=".repeat(60));
    println!("Summary:");
    println!("  - Cascading: Generates all candidates upfront, manual filtering");
    println!("  - Guided: Fast, iterative, good balance");
    println!("  - DFS: Quick to find *a* minimal, may not be *the* minimal");
    println!("  - BFS: Slowest but finds truly minimal counterexample");
    println!("\nChoose based on:");
    println!("  - How expensive is your test?");
    println!("  - How minimal does the result need to be?");
    println!("  - How much time do you have?");
}

pub fn with_max_depth(self, max_depth: usize) -> Self

Set maximum search depth

Examples found in repository

examples/advanced_shrinking.rs (line 120)

fn example_3_configurable_shrinker_dfs() {
    println!("Example 3: ConfigurableShrinker - Depth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (DFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nDepth-First Strategy:");
    println!("  - Follows the first successful shrink immediately");
    println!("  - Goes deep before exploring alternatives");
    println!("  - Fast but may not find the absolute minimal");
    println!("  - Good when any reasonably small counterexample is sufficient");
}

/// Example 4: ConfigurableShrinker with Breadth-First Search
fn example_4_configurable_shrinker_bfs() {
    println!("Example 4: ConfigurableShrinker - Breadth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (BFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nBreadth-First Strategy:");
    println!("  - Explores all shrinks at current depth before going deeper");
    println!("  - More thorough exploration");
    println!("  - Finds the truly minimal counterexample");
    println!("  - Slower but more comprehensive");
}

/// Example 5: Comparing all strategies on the same problem
fn example_5_comparing_strategies() {
    println!("Example 5: Strategy Comparison");
    println!("{}", "-".repeat(60));

    // Problem: Find minimal subset where sum of squares > 500
    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    let sum_of_squares = |v: &Vec<i32>| v.iter().map(|x| x * x).sum::<i32>();

    println!("Original vector: {:?}", original);
    println!("Sum of squares: {}", sum_of_squares(&original));
    println!("\nFinding minimal subset where sum of squares > 500\n");

    // Strategy 1: Cascading (manual exploration)
    let cascading = CascadingShrinker::new(original.clone());
    let candidates: Vec<_> = cascading.shrink().collect();
    let cascading_result = candidates
        .iter()
        .filter(|v| sum_of_squares(v) > 500)
        .min_by_key(|v| v.len())
        .cloned();

    if let Some(result) = cascading_result {
        println!("1. CascadingShrinker:");
        println!("   Result: {:?}", result);
        println!("   Length: {}", result.len());
        println!("   Sum of squares: {}", sum_of_squares(&result));
        println!("   Total candidates explored: {}", candidates.len());
    }

    // Strategy 2: Guided
    let guided = GuidedShrinker::new(original.clone());
    let (guided_result, guided_iterations) =
        guided.find_minimal_with_stats(|v| sum_of_squares(v) > 500);

    println!("\n2. GuidedShrinker:");
    println!("   Result: {:?}", guided_result);
    println!("   Length: {}", guided_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&guided_result));
    println!("   Iterations: {}", guided_iterations);

    // Strategy 3: DFS
    let dfs =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);
    let dfs_result = dfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n3. ConfigurableShrinker (DFS):");
    println!("   Result: {:?}", dfs_result);
    println!("   Length: {}", dfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&dfs_result));

    // Strategy 4: BFS
    let bfs = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);
    let bfs_result = bfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n4. ConfigurableShrinker (BFS):");
    println!("   Result: {:?}", bfs_result);
    println!("   Length: {}", bfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&bfs_result));

    println!("\n{}", "=".repeat(60));
    println!("Summary:");
    println!("  - Cascading: Generates all candidates upfront, manual filtering");
    println!("  - Guided: Fast, iterative, good balance");
    println!("  - DFS: Quick to find *a* minimal, may not be *the* minimal");
    println!("  - BFS: Slowest but finds truly minimal counterexample");
    println!("\nChoose based on:");
    println!("  - How expensive is your test?");
    println!("  - How minimal does the result need to be?");
    println!("  - How much time do you have?");
}

pub fn strategy(&self) -> ShrinkStrategy

Get the current strategy

impl<T: Clone + Debug + PartialEq + 'static> ConfigurableShrinker<Vec<T>>

pub fn find_minimal<F>(&self, test: F) -> Vec<T>

where F: Fn(&Vec<T>) -> bool,

Find minimal case using the configured strategy

Examples found in repository

examples/advanced_shrinking.rs (line 123)

fn example_3_configurable_shrinker_dfs() {
    println!("Example 3: ConfigurableShrinker - Depth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (DFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nDepth-First Strategy:");
    println!("  - Follows the first successful shrink immediately");
    println!("  - Goes deep before exploring alternatives");
    println!("  - Fast but may not find the absolute minimal");
    println!("  - Good when any reasonably small counterexample is sufficient");
}

/// Example 4: ConfigurableShrinker with Breadth-First Search
fn example_4_configurable_shrinker_bfs() {
    println!("Example 4: ConfigurableShrinker - Breadth-First Search");
    println!("{}", "-".repeat(60));

    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    println!("Original vector: {:?}", original);

    let shrinker = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);

    println!("\nFinding minimal subset with length >= 3 (BFS)...");
    let minimal = shrinker.find_minimal(|v| v.len() >= 3);

    println!("Minimal vector: {:?}", minimal);
    println!("Length: {}", minimal.len());

    println!("\nBreadth-First Strategy:");
    println!("  - Explores all shrinks at current depth before going deeper");
    println!("  - More thorough exploration");
    println!("  - Finds the truly minimal counterexample");
    println!("  - Slower but more comprehensive");
}

/// Example 5: Comparing all strategies on the same problem
fn example_5_comparing_strategies() {
    println!("Example 5: Strategy Comparison");
    println!("{}", "-".repeat(60));

    // Problem: Find minimal subset where sum of squares > 500
    let original = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    let sum_of_squares = |v: &Vec<i32>| v.iter().map(|x| x * x).sum::<i32>();

    println!("Original vector: {:?}", original);
    println!("Sum of squares: {}", sum_of_squares(&original));
    println!("\nFinding minimal subset where sum of squares > 500\n");

    // Strategy 1: Cascading (manual exploration)
    let cascading = CascadingShrinker::new(original.clone());
    let candidates: Vec<_> = cascading.shrink().collect();
    let cascading_result = candidates
        .iter()
        .filter(|v| sum_of_squares(v) > 500)
        .min_by_key(|v| v.len())
        .cloned();

    if let Some(result) = cascading_result {
        println!("1. CascadingShrinker:");
        println!("   Result: {:?}", result);
        println!("   Length: {}", result.len());
        println!("   Sum of squares: {}", sum_of_squares(&result));
        println!("   Total candidates explored: {}", candidates.len());
    }

    // Strategy 2: Guided
    let guided = GuidedShrinker::new(original.clone());
    let (guided_result, guided_iterations) =
        guided.find_minimal_with_stats(|v| sum_of_squares(v) > 500);

    println!("\n2. GuidedShrinker:");
    println!("   Result: {:?}", guided_result);
    println!("   Length: {}", guided_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&guided_result));
    println!("   Iterations: {}", guided_iterations);

    // Strategy 3: DFS
    let dfs =
        ConfigurableShrinker::new(original.clone(), ShrinkStrategy::DepthFirst).with_max_depth(20);
    let dfs_result = dfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n3. ConfigurableShrinker (DFS):");
    println!("   Result: {:?}", dfs_result);
    println!("   Length: {}", dfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&dfs_result));

    // Strategy 4: BFS
    let bfs = ConfigurableShrinker::new(original.clone(), ShrinkStrategy::BreadthFirst)
        .with_max_depth(20);
    let bfs_result = bfs.find_minimal(|v| sum_of_squares(v) > 500);

    println!("\n4. ConfigurableShrinker (BFS):");
    println!("   Result: {:?}", bfs_result);
    println!("   Length: {}", bfs_result.len());
    println!("   Sum of squares: {}", sum_of_squares(&bfs_result));

    println!("\n{}", "=".repeat(60));
    println!("Summary:");
    println!("  - Cascading: Generates all candidates upfront, manual filtering");
    println!("  - Guided: Fast, iterative, good balance");
    println!("  - DFS: Quick to find *a* minimal, may not be *the* minimal");
    println!("  - BFS: Slowest but finds truly minimal counterexample");
    println!("\nChoose based on:");
    println!("  - How expensive is your test?");
    println!("  - How minimal does the result need to be?");
    println!("  - How much time do you have?");
}

Trait Implementations

impl<T: Clone> Clone for ConfigurableShrinker<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ConfigurableShrinker<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.