How to store the prompt into a vector collection and then loop it?

[toriqahmads]

Hi, thank you for creating this crate before
Currently I use this crate, but didn't see a feature for storing the prompt questions into a vector first. So, I try to achieve this with my very limited knowledge in rust. I try with this code, but I'm very struggle how to deal with the generic type in vector especially in closure validator.

I want to do this like requestty and a survery lib in golang does
requestty: https://github.com/Lutetium-Vanadium/requestty/blob/master/examples/macros.rs
survey: https://github.com/AlecAivazis/survey

It's possible to do this? if it does, how to do it?

Thank you so much

this my code

pub struct Question<T, U: PartialEq + PartialOrd> {
    pub name: String,
    pub prompt: PromptType,
    pub message: String,
    pub default_value: Option<String>,
    pub error_message: Option<String>,
    pub help_message: Option<String>,
    pub options: Option<Vec<T>>,
    pub validator: Option<Box<dyn CustomTypeValidator<U>>> 
}

#[derive(Debug)]
pub struct BuyAnswers {
    pub target: String,
    pub amount: f64,
    pub number_of_buy: u8,
    pub number_of_recipient: u8,
    pub mode: String,
    pub additional_setting: Vec<String>
}

impl BuyAnswers {
    pub fn new() -> Self {
        Self {
            target: String::new(),
            amount: 0.0,
            number_of_buy: 0,
            number_of_recipient: 0,
            mode: String::new(),
            additional_setting: vec![]
        }
    }

    pub fn parse_buy_questions(&mut self) -> () {
        let questions = vec![
            Question {
                name: "amount".to_string(),
                prompt: PromptType::FloatingNumber,
                message: "Amount : ".to_string(),
                default_value: Some("0.001".to_string()),
                error_message: Some("Please input a valid amount!".to_string()),
                help_message: Some("Use US format for input amount!".to_string()),
                options: None,
                validator: Some(Box::new(|input: &f64| {
                    if *input >= 0.001 {
                        Ok(Validation::Valid)
                    } else {
                        Ok(Validation::Invalid("At leat 0.001 amount!".into()))
                    }
                })),
            },
            Question {
                name: "mode".to_string(),
                prompt: PromptType::Select,
                message: "Mode : ".to_string(),
                default_value: None,
                error_message: None,
                help_message: Some("You need to select one!".to_string()),
                // want the options to accept a generic type. Maybe a String vector or other
                options: Some(Mode::MODES.to_vec()),
                validator: None
            }
        ];

        for question in questions.iter() {
            let answer: Option<String> = match question.prompt {
                PromptType::Text => {
                    let mut prompt = Text::new(question.message.as_str());
                    if !question.default_value.is_none() {
                        prompt = prompt.with_default(&question.default_value.as_ref().unwrap());
                    }
                    if !question.help_message.is_none() {
                        prompt = prompt.with_help_message(&question.help_message.as_ref().unwrap());
                    }

                    Some(prompt.prompt().unwrap().to_string())
                },
                PromptType::Select => {
                    let mut prompt = Select::new(question.message.as_str(), question.options.as_ref().unwrap().to_vec());
                    if !question.help_message.is_none() {
                        prompt = prompt.with_help_message(&question.help_message.as_ref().unwrap());
                    }

                    Some(prompt.prompt().unwrap().to_string())
                },
                PromptType::FloatingNumber => {
                    let mut prompt = CustomType::<f64>::new(question.message.as_str());
                    if !question.default_value.is_none() {
                        prompt = prompt.with_default(question.default_value.as_ref().unwrap().parse::<f64>().unwrap());
                    }
                    if !question.error_message.is_none() {
                        prompt = prompt.with_error_message(&question.error_message.as_ref().unwrap());
                    }
                    if !question.help_message.is_none() {
                        prompt = prompt.with_help_message(&question.help_message.as_ref().unwrap());
                    }
                    if !question.validator.is_none() {
                        // want achieve like this with generic type
                        prompt = prompt.with_validator(&question.validator);
                    }

                    Some(prompt.prompt().unwrap().to_string())
                },
                PromptType::IntegerNumber => {
                    let mut prompt = CustomType::<u8>::new(question.message.as_str());
                    if !question.default_value.is_none() {
                        prompt = prompt.with_default(question.default_value.as_ref().unwrap().parse::<u8>().unwrap());
                    }
                    if !question.error_message.is_none() {
                        prompt = prompt.with_error_message(&question.error_message.as_ref().unwrap());
                    }
                    if !question.help_message.is_none() {
                        prompt = prompt.with_help_message(&question.help_message.as_ref().unwrap());
                    }

                    Some(prompt.prompt().unwrap().to_string())
                }
                _ => None,
            };

            if !answer.is_none() {
                self.parse_answer(&question.name, answer.unwrap());
            }
        }
    }

    fn parse_answer<T>(&mut self, question: &str, answer: T) where T: Into<String> {
        match question {
            "target" => self.target = answer.into(),
            "amount" => self.amount = answer.into().parse::<f64>().unwrap(),
            "number_of_buy" => self.number_of_buy = answer.into().parse::<u8>().unwrap(),
            "number_of_recipient" => self.number_of_recipient = answer.into().parse::<u8>().unwrap(),
            "mode" => self.mode = answer.into(),
            _ => ()
        }
    } 
}