traits.rs

impl<T> Monad<T, Vec<T>> for Vec<T> {                                                                                                                          
                                                                                                                                                               
    fn returns(inside: T) -> Self {                                                                                                                            
        vec!(inside)                                                                                                                                           
    }                                                                                                                                                          
                                                                                                                                                               
    fn bind<'a>(outside: Self, op: Box<Fn(T) -> Self + 'a>) -> Self                                                                                            
    {                                                                                                                                                          
        outside                                                                                                                                                
            .into_iter()                                                                                                                                       
            .fold(vec![], |mut agg, x| {                                                                                                                       
                let mut c = &mut op(x);                                                                                                                        
                agg.append(c);                                                                                                                                 
                agg                                                                                                                                            
            })                                                                                                                                                 
    }                                                                                                                                                          
}                                                                                                                                                              
                                                                                                                                                               
impl<T> Monad<T, Vec<Vec<T>>> for Vec<T> {                                                                                                                     
                                                                                                                                                               
    fn returns(inside: T) -> Self {                                                                                                                            
        vec!(inside)                                                                                                                                           
    }                                                                                                                                                          
                                                                                                                                                               
    fn bind<'a>(outside: Self, op: Box<Fn(T) -> Vec<Vec<T>> + 'a>) -> Vec<Vec<T>>                                                                              
    {                                                                                                                                                          
        outside                                                                                                                                                
            .into_iter()                                                                                                                                       
            .fold(vec![], |mut agg, x| {                                                                                                                       
                let mut c = &mut op(x);                                                                                                                        
                agg.append(c);                                                                                                                                 
                agg                                                                                                                                            
            })                                                                                                                                                 
    }                                                                                                                                                          
}