use std::fmt;                                                                                             
use std::string::String;                                                                                  
                                                                                                          
enum FizzBuzz {                                                                                           
        Fizz,                                                                                             
        Buzz,                                                                                             
        FizzBuzz,                                                                                         
        Other(i32)                                                                                        
}                                                                                                         
                                                                                                          
fn toFizzBuzz (x: &i32) -> FizzBuzz {                                                                     
        match x {                                                                                         
                _ if *x % 3 == 0 && *x % 5 == 0 => FizzBuzz::FizzBuzz,                                    
                _ if *x % 3 == 0 => FizzBuzz::Fizz,                                                       
                _ if *x % 5 == 0 => FizzBuzz::Buzz,                                                       
                _ => FizzBuzz::Other(*x)                                                                  
        }                                                                                                 
}                                                                                                         
                                                                                                          
impl fmt::Display for FizzBuzz {                                                                          
        fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {                                 
                f.write_fmt(format_args!("{}", match self {                                               
                        &FizzBuzz::Fizz => String::from_str("Fizz"),                                      
                        &FizzBuzz::Buzz => String::from_str("Buzz"),                                      
                        &FizzBuzz::FizzBuzz => String::from_str("FizzBuzz"),                              
                        &FizzBuzz::Other(x) => x.to_string()                                              
                }));                                                                                      
                return Ok(());                                                                            
        }                                                                                                 
}                                                                                                         
                                                                                                          
fn main () {                                                                                              
        let input = vec![1, 3, 5, 15, 20, 21];                                                            
        for x in input.iter().map(toFizzBuzz) {                                                           
                println!("{}", x);                                                                        
        }                                                                                                 
}