impl<T, V, O, E> Validate<[T]> for V
where
    Self: Validate<T, Output = Result<O, E>>,
{
    type Output = Result<Vec<O>, E>;

    fn validate(&mut self, nodes: &[T]) -> Self::Output {
        nodes.iter().map(|node| self.validate(node)).collect()
    }
}

impl Analyzer {
    /// Validates and store errors if required.
    pub fn check<T, O>(&mut self, node: &T) -> Option<O>
    where
        Self: Validate<T, Output = Result<O, Error>>,
    {
        let res: Result<O, _> = self.validate(node);
        match res {
            Ok(v) => Some(v),
            Err(..) => {
                // handle error
                None
            }
        }
    }
}

fn main() {
    let mut a = Analyzer;
    let expr = Expr;
    // Uncomment this to see impl for [T] explodes
    // a.check(&expr);

    // This works without error
    a.check::<Expr, ()>(&expr);
}