Member-level macro to use differently-named fallible constructor method?

[lkdm]

Hello!

Is there a recommended way to use a different method to use for constructing a property?

This would be useful for interop with the nutype crate which, when declaring validation rules, enforces the use of a fallible constructor try_new instead of new.

Sorry if this is out of scope for the crate– but I would appreciate any pointers :)

// title.rs
#[nutype(
        sanitize(trim),
        validate(with = validate_title, error = TitleError),
        derive(
            Clone, Debug, Display, PartialEq, Eq, PartialOrd, Ord, Deref, AsRef, Borrow, TryFrom, From
        )
)]
pub struct Title(String);

mod tests {
    #[cfg(test)]
    use super::*;

    #[test]
    fn test_create_project_title() {
        // 🤔 Will get compiler error if I use `new` constructor.
        let title = Title::try_new("checking that this is a valid filename");
        assert!(title.is_ok(), "A valid Title should be ok. Result: {:?}", title);
   }
}

// projects.rs
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, From)]
#[builder]
pub struct Project {
    #[builder(try_new)] // 🤔 This syntax does not work obviously, but I'd love to use `try_new` instead of `new`.
    title: Title,
}


mod tests {
    #[cfg(test)]
    use super::*;

    #[test]
    fn test_create_project() {
        let project = Project::builder()
            .title(String::from("test-title")) // 🤔 want to pass in String
            .build();

        assert_eq!(*project.title, "test-title");
    }
}

[lkdm]

Please ignore me, I found the article here which points out that I should be using a function builder.

Here's an example of my code, in case its helpful to anyone:

#[derive(Error, Debug, Clone, PartialEq)]
enum ProjectError {
    #[error("Error")]
    TitleError(#[from] TitleError)
}

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, From)]
pub struct Project {
    title: Title,
}

#[bon]
impl Project {
    #[builder]
    fn new(title: &str) -> Result<Self, ProjectError> {
        let title = Title::try_new(title.to_string())?;
        Ok(Self {title})
    }
}


mod tests {
    #[cfg(test)]
    use super::*;

    #[test]
    fn test_create_project() {
        let project = Project::builder()
            .title("test-title")
            .build();

        assert!(project.is_ok());
    }
}

[Veetaha]

Yeah, this is the only way today. A set of attributes for fallible conversions would be cool to reduce the syntax, but I think this is good enough until we have a good design for such a set of attributes (which isn't in focus right now yet).

[lkdm]

@Veetaha I wouldn't stress, the function-based builder works fine. Great crate btw.