use rayon::prelude::*;
 
fn main() {
    let data = vec![1, 2, 3, 4, 5];
    
    // reduce: identity + operation
    let sum = data.par_iter().reduce(|| 0, |a, b| a + b);
    println!("Sum: {}", sum);  // 15
    
    // The identity element (0) is used:
    // 1. As starting value for each thread's local reduction
    // 2. As the return value for empty splits
    // 3. As the base case for the final merge
    
    // For multiplication:
    let product = data.par_iter().reduce(|| 1, |a, b| a * b);
    println!("Product: {}", product);  // 120 (5!)
    
    // For string concatenation:
    let concatenated = data.par_iter()
        .map(|n| n.to_string())
        .reduce(String::new, |a, b| a + &b);
    println!("Concatenated: {}", concatenated);  // "12345"
}

use rayon::prelude::*;
 
fn main() {
    let data = vec![1, 2, 3, 4, 5];
    
    // reduce_with: operation only, returns Option
    let sum = data.par_iter().reduce_with(|a, b| a + b);
    println!("Sum: {:?}", sum);  // Some(15)
    
    let product = data.par_iter().reduce_with(|a, b| a * b);
    println!("Product: {:?}", product);  // Some(120)
    
    // For empty iterator:
    let empty: Vec<i32> = vec![];
    let result = empty.par_iter().reduce_with(|a, b| a + b);
    println!("Empty result: {:?}", result);  // None
    
    // Must handle the Option:
    match result {
        Some(value) => println!("Got: {}", value),
        None => println!("No elements"),
    }
}

use rayon::prelude::*;
 
fn main() {
    let empty: Vec<i32> = vec![];
    
    // reduce: Returns identity for empty
    let sum = empty.par_iter().reduce(|| 0, |a, b| a + b);
    assert_eq!(sum, 0);  // Identity returned
    
    // reduce_with: Returns None for empty
    let sum_opt = empty.par_iter().reduce_with(|a, b| a + b);
    assert_eq!(sum_opt, None);
    
    // This affects API design:
    // reduce: Result type is T (guaranteed)
    // reduce_with: Result type is Option<T> (may be absent)
    
    // Example: Finding minimum
    let min_reduce = empty.par_iter().reduce(|| i32::MAX, |a, b| a.min(b));
    println!("Min (reduce): {}", min_reduce);  // i32::MAX
    
    let min_reduce_with = empty.par_iter().reduce_with(|a, b| a.min(b));
    println!("Min (reduce_with): {:?}", min_reduce_with);  // None
}

use rayon::prelude::*;
 
fn main() {
    // In parallel execution, data is split into chunks
    // Each thread processes a chunk independently
    
    // For reduce:
    // Thread 1 processes [1, 2] -> reduce to 3
    // Thread 2 processes [3, 4] -> reduce to 7
    // Thread 3 processes [5]    -> reduce to 5
    // Thread 4 processes []     -> reduce to 0 (identity!)
    // Final merge: 3 + 7 + 5 + 0 = 15
    
    let data = vec![1, 2, 3, 4, 5];
    let result = data.par_iter().reduce(|| 0, |a, b| a + b);
    println!("Result: {}", result);
    
    // For reduce_with:
    // Thread 1 processes [1, 2] -> Some(3)
    // Thread 2 processes [3, 4] -> Some(7)
    // Thread 3 processes [5]    -> Some(5)
    // Thread 4 processes []     -> None (skipped)
    // Final merge: Some(3 + 7 + 5) = Some(15)
    
    let result = data.par_iter().reduce_with(|a, b| a + b);
    println!("Result: {:?}", result);
    
    // Empty chunks can occur in parallel splits!
    // reduce handles them with identity
    // reduce_with propagates None through the reduction
}

use rayon::prelude::*;
 
fn main() {
    // The identity MUST satisfy:
    // identity op x = x (left identity)
    // x op identity = x (right identity)
    
    // Correct identities:
    // Addition: 0 (0 + x = x, x + 0 = x)
    // Multiplication: 1 (1 * x = x, x * 1 = x)
    // String concat: "" ("" + s = s, s + "" = s)
    // Maximum: i32::MIN (max(MIN, x) = x)
    // Minimum: i32::MAX (min(MAX, x) = x)
    
    // Example: Finding maximum
    let data = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let max = data.par_iter().reduce(|| i32::MIN, |a, b| a.max(b));
    println!("Max: {}", max);  // 9
    
    // Wrong identity would give wrong results:
    // Using 0 for max would give at least 0, even if all values are negative
    let negatives = vec![-5, -3, -8, -1];
    let wrong_max = negatives.par_iter().reduce(|| 0, |a, b| a.max(b));
    println!("Wrong max: {}", wrong_max);  // 0 (wrong!)
    
    let correct_max = negatives.par_iter().reduce(|| i32::MIN, |a, b| a.max(b));
    println!("Correct max: {}", correct_max);  // -1
}

use rayon::prelude::*;
 
fn main() {
    // Use reduce when:
    // 1. You have a natural identity element
    // 2. Empty collections should return a sensible default
    // 3. You want a non-optional result type
    
    // Sum with default of 0
    let data = vec![10, 20, 30];
    let total = data.par_iter().reduce(|| 0, |a, b| a + b);
    println!("Total: {}", total);  // 60, not Some(60)
    
    // String concatenation with default of ""
    let words = vec!["hello", "world"];
    let sentence = words.par_iter()
        .reduce(|| String::new, |mut a, b| {
            if a.is_empty() {
                b.to_string()
            } else {
                a.push(' ');
                a.push_str(b);
                a
            }
        });
    println!("Sentence: {}", sentence);
    
    // Boolean AND (conjunction) - identity is true
    let flags = vec![true, true, false];
    let all_true = flags.par_iter().reduce(|| true, |a, b| a && b);
    println!("All true: {}", all_true);  // false
    
    // Boolean OR (disjunction) - identity is false
    let any_true = flags.par_iter().reduce(|| false, |a, b| a || b);
    println!("Any true: {}", any_true);  // true
}

use rayon::prelude::*;
 
fn main() {
    // Use reduce_with when:
    // 1. There's no natural identity element
    // 2. Empty collections are exceptional cases
    // 3. You want to distinguish empty from present
    
    // Finding minimum/maximum without artificial identity
    let data = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let min = data.par_iter().reduce_with(|a, b| a.min(b));
    println!("Min: {:?}", min);  // Some(1)
    
    // For empty data, None is more honest than i32::MAX
    let empty: Vec<i32> = vec![];
    let min = empty.par_iter().reduce_with(|a, b| a.min(b));
    assert_eq!(min, None);  // "No minimum exists" is semantically correct
    
    // Example: Processing optional data
    struct Record {
        value: Option<f64>,
    }
    
    let records = vec![
        Record { value: Some(1.5) },
        Record { value: None },
        Record { value: Some(2.5) },
    ];
    
    // Find max of present values
    let max = records.par_iter()
        .filter_map(|r| r.value)
        .reduce_with(|a, b| a.max(b));
    println!("Max value: {:?}", max);  // Some(2.5)
    
    // If no values present, None naturally indicates that
}

use rayon::prelude::*;
 
fn main() {
    // Both reduce and reduce_with require ASSOCIATIVE operations
    // (a op b) op c = a op (b op c)
    
    // Associative (correct):
    // Addition: (a + b) + c = a + (b + c)
    // Multiplication: (a * b) * c = a * (b * c)
    // Maximum: max(max(a, b), c) = max(a, max(b, c))
    
    // Non-associative (incorrect results possible):
    // Subtraction: (a - b) - c != a - (b - c)
    // Division: (a / b) / c != a / (b / c)
    
    let data = vec![100, 50, 25, 5];
    
    // WRONG: Subtraction is not associative
    let bad_result = data.par_iter().reduce(|| 0, |a, b| a - b);
    // Result depends on parallel split order!
    
    // Correct approach: Transform to associative operation
    // Sum of signed values
    let sum = data.par_iter().reduce(|| 0, |a, b| a + b);
    println!("Sum: {}", sum);  // 180 (well-defined)
    
    // For subtraction, use fold or scan with sequential processing
}

// | Aspect              | reduce                    | reduce_with              |
// |---------------------|---------------------------|-------------------------|
// | Identity element    | Required                  | Not used                |
// | Empty iterator      | Returns identity          | Returns None            |
// | Return type         | T                         | Option<T>               |
// | Parameters          | 2 (identity, operation)   | 1 (operation)           |
// | Use case            | Has natural identity      | No natural identity     |
// | Parallel splits     | Uses identity for empty    | Skips empty chunks      |
// | Semantic meaning    | "Fold with default"       | "Reduce if non-empty"   |

use rayon::prelude::*;
 
fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let empty: Vec<i32> = vec![];
    
    // reduce_with to reduce: Provide default after
    let result = data.par_iter()
        .reduce_with(|a, b| a + b)
        .unwrap_or(0);  // Convert None to identity
    
    // reduce to reduce_with: Filter out identity
    // (Not directly convertible - reduce_with is more restrictive)
    
    // Common pattern: reduce_with for max/min
    let max = data.par_iter().reduce_with(|a, b| a.max(b));
    let max_with_default = data.par_iter().reduce(|| i32::MIN, |a, b| a.max(b));
    // Both work, but reduce_with's None is more honest for empty case
    
    // Pattern: reduce for aggregation with sensible default
    let sum = data.par_iter().reduce(|| 0, |a, b| a + b);
    // 0 is meaningful: "sum of nothing is zero"
    
    // Anti-pattern: Using artificial identity
    // For max, using 0 as identity is wrong for negative numbers
    // Use reduce_with or true identity (i32::MIN)
}

use rayon::prelude::*;
 
#[derive(Debug, Clone)]
struct Stats {
    count: usize,
    sum: f64,
    min: f64,
    max: f64,
}
 
impl Stats {
    fn new(value: f64) -> Self {
        Stats {
            count: 1,
            sum: value,
            min: value,
            max: value,
        }
    }
    
    fn identity() -> Self {
        Stats {
            count: 0,
            sum: 0.0,
            min: f64::INFINITY,
            max: f64::NEG_INFINITY,
        }
    }
    
    fn merge(mut a: Self, b: Self) -> Self {
        Stats {
            count: a.count + b.count,
            sum: a.sum + b.sum,
            min: a.min.min(b.min),
            max: a.max.max(b.max),
        }
    }
}
 
fn main() {
    let data = vec![1.0, 2.5, 3.7, 0.5, 4.2];
    
    // reduce with custom type
    let stats = data.par_iter()
        .map(|&x| Stats::new(x))
        .reduce(Stats::identity, Stats::merge);
    
    println!("Stats: count={}, sum={}, min={}, max={}", 
        stats.count, stats.sum, stats.min, stats.max);
    
    // For empty data:
    let empty: Vec<f64> = vec![];
    let empty_stats = empty.par_iter()
        .map(|&x| Stats::new(x))
        .reduce(Stats::identity, Stats::merge);
    
    println!("Empty stats: count={}", empty_stats.count);  // 0
    // Identity provides meaningful "no data" statistics
}

use rayon::prelude::*;
 
fn main() {
    // reduce has minimal overhead from identity:
    // - Identity is called once per empty chunk
    // - Final merge includes identity values (neutral operation)
    
    // reduce_with has no identity overhead:
    // - Empty chunks produce None (cheap)
    // - Merging skips None values
    
    // For small iterators:
    let small = vec![1, 2, 3];
    
    // reduce calls identity for initial value, then reduces
    // reduce_with starts with first element, then reduces
    
    // The performance difference is typically negligible
    // Choose based on semantics, not performance
    
    // For very large parallel splits, reduce_with might be slightly faster
    // because it skips the identity allocation/call
    
    // Memory considerations:
    // reduce: Identity must be cheap to create
    // reduce_with: No allocation for empty case
    
    // Example: String concatenation
    let words = vec!["hello", "world"];
    
    // reduce: Creates "" for each empty chunk
    let result = words.par_iter()
        .reduce(String::new, |mut a, b| {
            if a.is_empty() { b.to_string() }
            else { a.push_str(b); a }
        });
    
    // reduce_with: No empty string creation
    let result = words.par_iter()
        .reduce_with(|a, b| a + b);
}

// Use reduce when:
// - Operation has natural identity (sum: 0, product: 1, AND: true)
// - Empty case should return a default
// - You want non-optional result type
let sum = data.par_iter().reduce(|| 0, |a, b| a + b);
 
// Use reduce_with when:
// - No natural identity (min/max over empty is undefined)
// - Empty case should be explicitly None
// - You need to distinguish "empty" from "default value"
let max = data.par_iter().reduce_with(|a, b| a.max(b));