update README

Author: tomoikey

Cargo.toml

@@ -6,16 +6,16 @@ repository = "https://github.com/tomoikey/refined-type"
 readme = "README.md"
 categories = ["accessibility", "development-tools", "rust-patterns"]
 license = "MIT"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-paste = "1.0.14"
-regex = "1.10.3"
-serde = { version = "1.0.197", features = ["derive"] }
+paste = "1.0.15"
+regex = "1.10.4"
+serde = { version = "1.0.203", features = ["derive"] }
 
 [dev-dependencies]
-anyhow = "1.0.80"
-serde_json = "1.0.114"
+anyhow = "1.0.86"
+serde_json = "1.0.117"

README.md

@@ -107,6 +107,7 @@ By using Rule Composer, composite rules can be easily created.
 
 ```rust
 struct ContainsHelloRule;
+
 struct ContainsWorldRule;
 
 impl Rule for ContainsHelloRule {
@@ -195,7 +196,9 @@ Therefore, it can be treated much like a composite function
 
 ```rust
 struct StartsWithHelloRule;
+
 struct StartsWithByeRule;
+
 struct EndsWithJohnRule;
 
 impl Rule for StartsWithHelloRule {
@@ -320,15 +323,19 @@ type TargetAgeRule = And<TargetAge18OrMore, TargetAge80OrLess>;
 ```
 
 # Iterator
+
 I have also prepared several useful refined types for Iterators.
+
 ## `ForAll`
+
 `ForAll` is a rule that applies a specific rule to all elements in the Iterator.
+
 ```rust
 fn example_11() -> anyhow::Result<()> {
     let vec = vec!["Hello".to_string(), "World".to_string()];
     let for_all_ok = ForAll::<NonEmptyStringRule, _>::new(vec.clone())?;
     assert_eq!(vec, for_all_ok.into_value());
-    
+
     let vec = vec!["Hello".to_string(), "".to_string()];
     let for_all_err = ForAll::<NonEmptyStringRule, _>::new(vec.clone());
     assert!(for_all_err.is_err());
@@ -337,7 +344,9 @@ fn example_11() -> anyhow::Result<()> {
 ```
 
 ## `Exists`
+
 `Exists` is a rule that applies a specific rule to at least one element in the Iterator.
+
 ```rust
 fn example_12() -> anyhow::Result<()> {
     let vec = vec!["Hello".to_string(), "".to_string()];
@@ -350,8 +359,11 @@ fn example_12() -> anyhow::Result<()> {
     Ok(())
 }
 ```
+
 ---
+
 ## `into_iter()` and `iter()`
+
 The Iterator I’ve prepared has `into_iter` and `iter` implemented.
 Therefore, you can easily map or convert it to a different Iterator using `collect`.
 Feel free to explore the capabilities of the Iterator you’ve been given!
@@ -420,6 +432,122 @@ fn example_15() -> anyhow::Result<()> {
 }
 ```
 
+# Length
+
+You can impose constraints on objects that have a length, such as `String` or `Vec`.
+
+### String
+
+```rust
+fn example_16() -> Result<(), Error> {
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Password = Refined<From5To10Rule<String>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 8. so, this is valid
+    let raw_password = "password";
+    let password = Password::new(raw_password.to_string())?;
+    assert_eq!(password.into_value(), "password");
+
+    // length is 4. so, this is invalid
+    let raw_password = "pswd";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+
+    // length is 17. so, this is invalid
+    let raw_password = "password password";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+
+    Ok(())
+}
+```
+
+### Vec
+
+```rust
+#[test]
+fn example_17() -> anyhow::Result<()> {
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Friends = Refined<From5To10Rule<Vec<String>>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 6. so, this is valid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yoshiko".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone())?;
+    assert_eq!(friends.into_value(), raw_friends);
+
+    // length is 2. so, this is invalid
+    let raw_friends = vec!["Tom".to_string(), "Taro".to_string()];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    // length is 11. so, this is invalid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yuiko".to_string(),
+        "Taiko".to_string(),
+        "John".to_string(),
+        "Jane".to_string(),
+        "Jack".to_string(),
+        "Jill".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    Ok(())
+}
+```
+
+### Custom Length
+
+You can define a length for any type. Therefore, if you want to implement a length that is not provided
+by `refined_type`, you can easily do so using `LengthDefinition`.
+
+```rust
+#[test]
+fn example_18() -> anyhow::Result<()> {
+    length_equal!(5);
+
+    #[derive(Debug, PartialEq)]
+    struct Hello;
+    impl LengthDefinition for Hello {
+        fn length(&self) -> usize {
+            5
+        }
+    }
+
+    let hello = Refined::<LengthEqualRule5<Hello>>::new(Hello)?;
+    assert_eq!(hello.into_value(), Hello);
+    Ok(())
+}
+```
+
 # Tips
 
 Directly writing `And`, `Or`, `Not` or `Refined` can often lead to a decrease in readability.

src/rule/length/length_definition.rs

@@ -33,7 +33,6 @@ impl<T> LengthDefinition for Vec<T> {
     }
 }
 
-// Implementions of Iteration
 impl<T> LengthDefinition for [T] {
     fn length(&self) -> usize {
         self.len()

tests/read_me.rs

@@ -1,12 +1,16 @@
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+
+use refined_type::{
+    equal_rule, greater_rule, length_equal, length_greater_than, length_less_than, less_rule,
+    Refined,
+};
 use refined_type::result::Error;
-use refined_type::rule::composer::{And, Not, Or};
 use refined_type::rule::{
-    Exists, ForAll, NonEmptyRule, NonEmptyString, NonEmptyStringRule, NonEmptyVec,
-    NonEmptyVecDeque, Rule,
+    Exists, ForAll, LengthDefinition, NonEmptyRule, NonEmptyString, NonEmptyStringRule,
+    NonEmptyVec, NonEmptyVecDeque, Rule,
 };
-use refined_type::{equal_rule, greater_rule, less_rule, Refined};
-use serde::{Deserialize, Serialize};
-use serde_json::json;
+use refined_type::rule::composer::{And, Not, Or};
 
 // define the constraints you expect by combining 'Refined' and 'Rule'.
 type MyNonEmptyString = Refined<NonEmptyRule<String>>;
@@ -298,22 +302,99 @@ fn example_15() -> anyhow::Result<()> {
 }
 
 #[test]
-fn example_16() -> anyhow::Result<()> {
-    let non_empty_string_1 = NonEmptyString::new("Hello".to_string())?;
-    let non_empty_string_2 = NonEmptyString::new("World".to_string())?;
-    let non_empty_string = non_empty_string_1 + non_empty_string_2; // This is also `NonEmptyString` type
+fn example_16() -> Result<(), Error> {
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Password = Refined<From5To10Rule<String>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 8. so, this is valid
+    let raw_password = "password";
+    let password = Password::new(raw_password.to_string())?;
+    assert_eq!(password.into_value(), "password");
+
+    // length is 4. so, this is invalid
+    let raw_password = "pswd";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+
+    // length is 17. so, this is invalid
+    let raw_password = "password password";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
 
-    assert_eq!(non_empty_string.into_value(), "HelloWorld");
     Ok(())
 }
 
 #[test]
 fn example_17() -> anyhow::Result<()> {
-    let ne_vec_1 = NonEmptyVec::new(vec![1, 2, 3])?;
-    let ne_vec_2 = NonEmptyVec::new(vec![4, 5, 6])?;
-    let ne_vec = ne_vec_1 + ne_vec_2; // This is also `NonEmptyVec` type
+    length_greater_than!(5);
+    length_equal!(5, 10);
+    length_less_than!(10);
+
+    type Friends = Refined<From5To10Rule<Vec<String>>>;
+
+    type From5To10Rule<T> = And<
+        Or<LengthEqualRule5<T>, LengthGreaterThanRule5<T>>,
+        Or<LengthLessThanRule10<T>, LengthEqualRule10<T>>,
+    >;
+
+    // length is 6. so, this is valid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yoshiko".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone())?;
+    assert_eq!(friends.into_value(), raw_friends);
+
+    // length is 2. so, this is invalid
+    let raw_friends = vec!["Tom".to_string(), "Taro".to_string()];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    // length is 11. so, this is invalid
+    let raw_friends = vec![
+        "Tom".to_string(),
+        "Taro".to_string(),
+        "Jiro".to_string(),
+        "Hanako".to_string(),
+        "Sachiko".to_string(),
+        "Yuiko".to_string(),
+        "Taiko".to_string(),
+        "John".to_string(),
+        "Jane".to_string(),
+        "Jack".to_string(),
+        "Jill".to_string(),
+    ];
+    let friends = Friends::new(raw_friends.clone());
+    assert!(friends.is_err());
+
+    Ok(())
+}
+
+#[test]
+fn example_18() -> anyhow::Result<()> {
+    #[derive(Debug, PartialEq)]
+    struct Hello;
+    impl LengthDefinition for Hello {
+        fn length(&self) -> usize {
+            5
+        }
+    }
 
-    assert_eq!(ne_vec.into_value(), vec![1, 2, 3, 4, 5, 6]);
+    length_equal!(5);
+    let hello = Refined::<LengthEqualRule5<Hello>>::new(Hello)?;
+    assert_eq!(hello.into_value(), Hello);
     Ok(())
 }