ai-agent 0.88.0

// Source: /data/home/swei/claudecode/openclaudecode/src/utils/array.ts
#![allow(dead_code)]

/// Intersperse elements from a slice with a separator generated by a function.
pub fn intersperse<T, F>(arr: &[T], separator: F) -> Vec<T>
where
    T: Clone,
    F: Fn(usize) -> T,
{
    let mut result = Vec::with_capacity(arr.len() * 2);
    for (i, item) in arr.iter().enumerate() {
        if i > 0 {
            result.push(separator(i));
        }
        result.push(item.clone());
    }
    result
}

/// Count elements in a slice that match a predicate.
pub fn count<T, F>(arr: &[T], pred: F) -> usize
where
    F: Fn(&T) -> bool,
{
    arr.iter().filter(|x| pred(x)).count()
}

/// Get unique elements from an iterable, preserving order.
pub fn uniq<T>(xs: impl IntoIterator<Item = T>) -> Vec<T>
where
    T: Eq + std::hash::Hash + Clone,
{
    let mut seen = std::collections::HashSet::new();
    xs.into_iter()
        .filter(|item| seen.insert(item.clone()))
        .collect()
}

pub fn chunk<T: Clone>(arr: &[T], size: usize) -> Vec<Vec<T>> {
    arr.chunks(size).map(|c| c.to_vec()).collect()
}

pub fn flatten<T: Clone>(arr: &[Vec<T>]) -> Vec<T> {
    arr.iter().flat_map(|v| v.iter().cloned()).collect()
}

pub fn unique<T: Eq + std::hash::Hash + Clone>(arr: &[T]) -> Vec<T> {
    let mut seen = std::collections::HashSet::new();
    arr.iter()
        .filter(|item| seen.insert((*item).clone()))
        .cloned()
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_chunk() {
        let arr = [1, 2, 3, 4, 5];
        assert_eq!(chunk(&arr, 2), vec![vec![1, 2], vec![3, 4], vec![5]]);
    }

    #[test]
    fn test_flatten() {
        let arr = vec![vec![1, 2], vec![3, 4]];
        assert_eq!(flatten(&arr), vec![1, 2, 3, 4]);
    }

    #[test]
    fn test_unique() {
        let arr = [1, 2, 1, 3, 2];
        assert_eq!(unique(&arr), vec![1, 2, 3]);
    }
}