Merge pull request #153 from greyblake/try-new

Deprecate fallible ::new() in favor of ::try_new()

CHANGELOG.md

@@ -1,7 +1,8 @@
 ### v0.x.x - 2024-xx-xx
 
-* Support newtypes with generics
-
+* Support generics
+* [DEPRECATION] Fallible constructor `::new()` is deprecated. Users should use `::try_new()` instead.
+* [FIX] Use absolute path for `::core::result::Result` when generating code for `derive(TryFrom)`.
 
 ### v0.4.2 - 2024-04-07
 

README.md

@@ -40,22 +40,22 @@ use nutype::nutype;
 )]
 pub struct Username(String);
 
-// We can obtain a value of Username with `::new()`.
+// We can obtain a value of Username with `::try_new()`.
 // Note that Username holds a sanitized string
 assert_eq!(
-    Username::new("   FooBar  ").unwrap().into_inner(),
+    Username::try_new("   FooBar  ").unwrap().into_inner(),
     "foobar"
 );
 
 // It's impossible to obtain an invalid Username
 // Note that we also got `UsernameError` enum generated implicitly
 // based on the validation rules.
 assert_eq!(
-    Username::new("   "),
+    Username::try_new("   "),
     Err(UsernameError::NotEmptyViolated),
 );
 assert_eq!(
-    Username::new("TheUserNameIsVeryVeryLong"),
+    Username::try_new("TheUserNameIsVeryVeryLong"),
     Err(UsernameError::LenCharMaxViolated),
 );
 ```
@@ -229,12 +229,12 @@ pub struct GuestList(Vec<String>);
 
 // Empty list is not allowed
 assert_eq!(
-    GuestList::new(vec![]),
+    GuestList::try_new(vec![]),
     Err(GuestListError::PredicateViolated)
 );
 
 // Create the list of our guests
-let guest_list = GuestList::new(vec![
+let guest_list = GuestList::try_new(vec![
     "Seneca".to_string(),
     "Marcus Aurelius".to_string(),
     "Socrates".to_string(),

dummy/src/main.rs

@@ -1,15 +1,6 @@
-use arbitrary::Arbitrary;
 use nutype::nutype;
 
-#[nutype(derive(Debug, Arbitrary))]
-struct Wrapper<T>(Vec<T>);
+#[nutype(validate(len_char_min = 5), default = "Anonymous", derive(Default))]
+pub struct Name(String);
 
-fn main() {
-    fn gen(bytes: &[u8]) -> Wrapper<bool> {
-        let mut u = arbitrary::Unstructured::new(bytes);
-        Wrapper::<bool>::arbitrary(&mut u).unwrap()
-    }
-    assert_eq!(gen(&[]).into_inner(), vec![]);
-    assert_eq!(gen(&[1]).into_inner(), vec![false]);
-    assert_eq!(gen(&[1, 3, 5]).into_inner(), vec![true, false]);
-}
+fn main() {}

examples/any_generics/src/main.rs

@@ -69,10 +69,10 @@ fn main() {
     // NotEmpty
     //
     {
-        let v = NotEmpty::new(vec![1, 2, 3]).unwrap();
+        let v = NotEmpty::try_new(vec![1, 2, 3]).unwrap();
         assert_eq!(v.into_inner(), vec![1, 2, 3]);
 
-        let err = NotEmpty::<i32>::new(vec![]).unwrap_err();
+        let err = NotEmpty::<i32>::try_new(vec![]).unwrap_err();
         assert_eq!(err, NotEmptyError::PredicateViolated);
     }
 

examples/float_sortable/src/main.rs

@@ -17,7 +17,7 @@ fn main() {
     // which excluded NaN values.
     let mut widths: Vec<Width> = raw_widths
         .into_iter()
-        .map(|w| Width::new(w).unwrap())
+        .map(|w| Width::try_new(w).unwrap())
         .collect();
 
     // Now we can sort
@@ -27,10 +27,10 @@ fn main() {
     assert_eq!(
         widths,
         vec![
-            Width::new(1.4).unwrap(),
-            Width::new(1.5).unwrap(),
-            Width::new(1.8).unwrap(),
-            Width::new(2.1).unwrap(),
+            Width::try_new(1.4).unwrap(),
+            Width::try_new(1.5).unwrap(),
+            Width::try_new(1.8).unwrap(),
+            Width::try_new(2.1).unwrap(),
         ],
     )
 }

examples/integer_bounded/src/main.rs

@@ -11,13 +11,16 @@ struct Volume(i8);
 
 fn main() {
     // Too small
-    assert_eq!(Volume::new(-101), Err(VolumeError::GreaterOrEqualViolated),);
+    assert_eq!(
+        Volume::try_new(-101),
+        Err(VolumeError::GreaterOrEqualViolated),
+    );
 
     // Too big
-    assert_eq!(Volume::new(101), Err(VolumeError::LessOrEqualViolated),);
+    assert_eq!(Volume::try_new(101), Err(VolumeError::LessOrEqualViolated),);
 
     // Valid values
-    assert_eq!(Volume::new(-100).unwrap().into_inner(), -100);
-    assert_eq!(Volume::new(0).unwrap().into_inner(), 0);
-    assert_eq!(Volume::new(100).unwrap().into_inner(), 100);
+    assert_eq!(Volume::try_new(-100).unwrap().into_inner(), -100);
+    assert_eq!(Volume::try_new(0).unwrap().into_inner(), 0);
+    assert_eq!(Volume::try_new(100).unwrap().into_inner(), 100);
 }

examples/serde_complex/src/main.rs

@@ -96,9 +96,9 @@ fn main() {
         assert_eq!(
             product,
             Product {
-                name: Name::new("FlySniper").unwrap(),
-                image_url: ImageUrl::new("https://example.com/image.jpg").unwrap(),
-                price: Price::new(9.99).unwrap(),
+                name: Name::try_new("FlySniper").unwrap(),
+                image_url: ImageUrl::try_new("https://example.com/image.jpg").unwrap(),
+                price: Price::try_new(9.99).unwrap(),
             }
         )
     }

examples/string_bounded_len/src/main.rs

@@ -13,7 +13,7 @@ const MAX_NAME_LEN: usize = 4;
 pub struct Name(String);
 
 fn main() {
-    assert_eq!(Name::new("Bo"), Err(NameError::LenCharMinViolated));
-    assert_eq!(Name::new("Julia"), Err(NameError::LenCharMaxViolated));
-    assert_eq!(Name::new("Jojo").unwrap().as_ref(), "Jojo");
+    assert_eq!(Name::try_new("Bo"), Err(NameError::LenCharMinViolated));
+    assert_eq!(Name::try_new("Julia"), Err(NameError::LenCharMaxViolated));
+    assert_eq!(Name::try_new("Jojo").unwrap().as_ref(), "Jojo");
 }

examples/string_regex_email/src/main.rs

@@ -23,19 +23,19 @@ struct Email(String);
 
 fn main() {
     // Too short
-    assert_eq!(Email::new("a@b"), Err(EmailError::LenCharMinViolated));
+    assert_eq!(Email::try_new("a@b"), Err(EmailError::LenCharMinViolated));
 
     // Too long
     assert_eq!(
-        Email::new("[email protected]"),
+        Email::try_new("[email protected]"),
         Err(EmailError::LenCharMaxViolated)
     );
 
     // Does not match the regex
-    assert_eq!(Email::new("foo@barcom"), Err(EmailError::RegexViolated));
+    assert_eq!(Email::try_new("foo@barcom"), Err(EmailError::RegexViolated));
 
     // A valid email
-    let email: Email = Email::new("\t [email protected] \n").unwrap();
+    let email: Email = Email::try_new("\t [email protected] \n").unwrap();
 
     // The underlying string that represents the email address is sanitized
     assert_eq!(email.as_ref(), "[email protected]");

nutype/Cargo.toml

@@ -17,6 +17,11 @@ categories = ["data-structures", "rust-patterns"]
 [dependencies]
 nutype_macros = { version = "0.4.2", path = "../nutype_macros" }
 
+[dev-dependencies]
+regex = "1.0"
+lazy_static = "1.0"
+once_cell = "1.0"
+
 [features]
 default = ["std"]