Allow items for `Select` that do not necessary implement `Display` but with an appropiate formatter. about inquire HOT 4 CLOSED

#[derive(AsChangeset, Identifiable, Insertable, Queryable, Serialize, PartialEq, Eq)]
#[table_name = "tag"]
#[changeset_options(treat_none_as_null = "true")]
pub struct Tag {
    pub id: Ulid,
    pub title: String,
    pub description: Option<String>,
}

struct TagSelectView(Tag);

impl Display for TagSelectView {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
        write!(f, "{}", self.0.title)?;

        if let Some(desc) = &self.0.description {
            write!(f, " ({:.40})", desc)?;
        }

        Ok(())
    }
}

pub struct TagSelector;

impl TagSelector {
    pub fn select_skippable_from(
        msg: &str,
        tags: Vec1<Tag>,
        help_msg: &str,
    ) -> Result<Option<Tag>> {
        let tags = tags.into_iter().map(TagSelectView).collect();
        let tag = inquire::Select::new(msg, tags)
            .with_help_message(help_msg)
            .prompt_skippable()?
            .map(|t| t.0);

        Ok(tag)
    }
}

struct CustomStructView(String, CustomStruct);

impl CustomStructView {
    fn filter(input: &str, obj: &CustomStructView, str_value: &str, idx: usize) -> bool {
        input.contains(&obj.0)
    }
}

impl Display for CustomStructView {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
        write!(f, "{} ({})", self.0, self.1.description)
    }
}

pub fn select(objs: Vec1<CustomStruct>) -> Result<CustomStruct> {
    let objs = tags.into_iter()
        .map(|cs| CustomStructView("something".to_string(), cs))
        .collect();
        
    inquire::Select::new("Select one please:", objs)
        .with_help_message("Help message")
        .with_filter(&CustomStructView::filter)
        .prompt()
        .map(|t| t.1)
}

pub struct Formatted<'a, T: ?Sized> {
    fmt: &'a dyn Fn(&T) -> String,
    value: T,
}

impl<'a, T> Formatted<'a, T> {
    pub fn new(value: T, fmt: &'a impl Fn(&T) -> String) -> Self {
        Self { fmt, value }
    }
}

impl<T: ?Sized> Display for Formatted<'_, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        (self.fmt)(&self.value).fmt(f)
    }
}

impl<T> Deref for Formatted<'_, T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

fn select(objs: Vec<(String, CustomStruct)>) {
    let objs = objs
        .into_iter()
        .map(|o| Formatted::new(o, &|o| format!("{}: {}", o.0, o.1.desc)))
        .collect();
    let select = Select::new("Select an object", objs).prompt().unwrap();
    // use select as if it were (String, CustomStruct)
    println!("{}", select.0);
}