update doc comment

Author: tomoikey

src/rule/empty.rs

@@ -13,7 +13,7 @@ use std::ops::Add;
 
 pub use empty_definition::EmptyDefinition;
 
-/// The `Empty` type is a type that indicates that its subject is empty.  
+/// A type that holds a value satisfying the `EmptyRule`
 /// The definition of empty is defined by `EmptyDefinition`.  
 ///
 /// # Example
@@ -38,7 +38,7 @@ where
     }
 }
 
-/// Rule where the data is empty
+/// Rule where the input value is empty
 /// ```rust
 /// use refined_type::rule::{EmptyRule, Rule};
 ///

src/rule/empty/empty_definition.rs

@@ -1,3 +1,4 @@
+/// This trait is used to define the empty method for a type.
 pub trait EmptyDefinition {
     fn empty(&self) -> bool;
 }

src/rule/non_empty.rs

@@ -15,11 +15,11 @@ pub use non_empty_string::*;
 pub use non_empty_vec::*;
 pub use non_empty_vec_deque::*;
 
-/// The `NonEmpty` type is a type that negates `Empty` using the `Not` composer.  
-/// It represents data that does not match the empty definition
+/// Refined type where the input value is not empty
+/// The definition of empty is defined by `EmptyDefinition`.
 pub type NonEmpty<T> = Refined<NonEmptyRule<T>>;
 
-/// Rule where the data is non-empty
+/// Rule where the input value is not empty
 /// ```rust
 /// use refined_type::rule::{NonEmptyRule, Rule};
 /// assert!(NonEmptyRule::<String>::validate(&"non empty".to_string()).is_ok());

src/rule/non_empty/non_empty_map.rs

@@ -6,7 +6,7 @@ use std::collections::hash_map::{IntoKeys, IntoValues, Keys, Values};
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hash};
 
-/// `NonEmptyHashMap` is a `HashMap` that follows the `NonEmptyRule`
+/// A type that holds a value satisfying the `NonEmptyHashMapRule`
 /// # Example
 /// ```rust
 /// # use std::collections::{HashMap, HashSet};
@@ -25,6 +25,8 @@ use std::hash::{BuildHasher, Hash};
 /// );
 /// ```
 pub type NonEmptyHashMap<K, V, S = RandomState> = Refined<NonEmptyHashMapRule<K, V, S>>;
+
+/// Rule where the input `HashMap` is not empty
 pub type NonEmptyHashMapRule<K, V, S = RandomState> = NonEmptyRule<HashMap<K, V, S>>;
 
 impl<K, V, S> NonEmptyHashMap<K, V, S> {

src/rule/non_empty/non_empty_set.rs

@@ -7,7 +7,7 @@ use std::collections::hash_map::RandomState;
 use std::collections::HashSet;
 use std::hash::{BuildHasher, Hash};
 
-/// `NonEmptyHashSet` is a `HashSet` that follows the `NonEmptyRule`
+/// A type that holds a value satisfying the `NonEmptyHashSetRule`
 /// # Example
 /// ```rust
 /// # use std::collections::HashSet;
@@ -22,6 +22,8 @@ use std::hash::{BuildHasher, Hash};
 /// assert_eq!(set.into_value(), set_origin);
 /// ```
 pub type NonEmptyHashSet<T, S = RandomState> = Refined<NonEmptyRule<HashSet<T, S>>>;
+
+/// Rule where the input `HashSet` is not empty
 pub type NonEmptyHashSetRule<T, S = RandomState> = NonEmptyRule<HashSet<T, S>>;
 
 impl<T, S> NonEmptyHashSet<T, S> {

src/rule/non_empty/non_empty_string.rs

@@ -4,7 +4,7 @@ use crate::rule::{NonEmptyRule, NonEmptyVec};
 use std::ops::Add;
 use std::str::FromStr;
 
-/// This is a predicate type representing a non-empty string
+/// A type that holds a value satisfying the `NonEmptyStringRule`
 ///
 /// # Example
 /// ```rust
@@ -17,6 +17,8 @@ use std::str::FromStr;
 /// assert_eq!(non_empty_string.into_value(), "HelloWorld");
 /// ```
 pub type NonEmptyString = Refined<NonEmptyStringRule>;
+
+/// Rule where the input `String` is not empty
 pub type NonEmptyStringRule = NonEmptyRule<String>;
 
 impl NonEmptyString {

src/rule/non_empty/non_empty_vec.rs

@@ -3,7 +3,7 @@ use crate::Refined;
 
 use std::ops::Add;
 
-/// `NonEmptyVec` is a `Vec` that follows the `NonEmptyRule`
+/// A type that holds a value satisfying the `NonEmptyVecRule`
 ///
 /// # Example
 /// ```rust
@@ -13,6 +13,8 @@ use std::ops::Add;
 /// assert_eq!(vec.into_value(), vec![1, 2, 3]);
 /// ```
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
+
+/// Rule where the input `Vec` is not empty
 pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
 
 impl<T> NonEmptyVec<T> {

src/rule/non_empty/non_empty_vec_deque.rs

@@ -3,7 +3,7 @@ use crate::Refined;
 use std::collections::VecDeque;
 use std::ops::Add;
 
-/// `NonEmptyVecDeque` is a `VecDeque` that follows the `NonEmptyRule`
+/// A type that holds a value satisfying the `NonEmptyVecDequeRule`
 ///
 /// # Example
 /// ```rust
@@ -17,6 +17,8 @@ use std::ops::Add;
 /// assert_eq!(deque.into_value(), vec![2, 1, 3]);
 /// ```
 pub type NonEmptyVecDeque<T> = Refined<NonEmptyVecDequeRule<T>>;
+
+/// Rule where the input `VecDeque` is not empty
 pub type NonEmptyVecDequeRule<T> = NonEmptyRule<VecDeque<T>>;
 
 impl<T> NonEmptyVecDeque<T> {

src/rule/number/equal.rs

@@ -6,6 +6,7 @@ macro_rules! equal_rule {
             #[allow(dead_code)]
             pub type [<Equal $e $t>] = $crate::Refined<[<EqualRule $e $t>]>;
 
+            /// Rule where the number is equal to `N`
             #[allow(dead_code)]
             pub struct [<EqualRule $e $t>];
 

src/rule/number/even.rs

@@ -5,6 +5,7 @@ macro_rules! even_rule {
             #[allow(dead_code)]
             pub type [<Even $t:upper>] = $crate::Refined<[<EvenRule $t:upper>]>;
 
+            /// Rule where the number is even
             #[allow(dead_code)]
             pub struct [<EvenRule $t:upper>];
 

src/rule/number/greater.rs

@@ -6,6 +6,7 @@ macro_rules! greater_rule {
             #[allow(dead_code)]
             pub type [<Greater $e $t>] = $crate::Refined<[<GreaterRule $e $t>]>;
 
+            /// Rule where the number is greater than `N`
             #[allow(dead_code)]
             pub struct [<GreaterRule $e $t>];
 

src/rule/number/less.rs

@@ -6,6 +6,7 @@ macro_rules! less_rule {
             #[allow(dead_code)]
             pub type [<Less $e $t>] = $crate::Refined<[<LessRule $e $t>]>;
 
+            /// Rule where the number is less than `N`
             #[allow(dead_code)]
             pub struct [<LessRule $e $t>];
 

src/rule/number/odd.rs

@@ -3,6 +3,7 @@ macro_rules! odd_rule {
         paste::item! {
             /// `Odd[TYPE]` is a type that represents that the number is odd.
             pub type [<Odd $t:upper>] = $crate::Refined<[<OddRule $t:upper>]>;
+            /// Rule where the number is odd
             pub struct [<OddRule $t:upper>];
 
             impl $crate::rule::Rule for [<OddRule $t:upper>] {

src/rule/string/alpha_digit.rs

@@ -3,7 +3,10 @@ use crate::rule::Rule;
 use crate::Refined;
 use regex::Regex;
 
+/// A type that holds a value satisfying the `AlphaDigitRule`
 pub type AlphaDigit = Refined<AlphaDigitRule>;
+
+/// Rule where the input `String` contains only alphabet and digit characters
 pub struct AlphaDigitRule;
 
 impl Rule for AlphaDigitRule {

src/rule/string/alphabet.rs

@@ -3,7 +3,7 @@ use crate::rule::Rule;
 use crate::Refined;
 use regex::Regex;
 
-/// The `Alphabet` type represents a type that can contain zero or more alphabetic characters.
+/// A type that holds a value satisfying the `AlphabetRule`
 ///
 /// # Example
 /// ```rust
@@ -17,7 +17,7 @@ use regex::Regex;
 /// ```
 pub type Alphabet = Refined<AlphabetRule>;
 
-/// A string consisting entirely of alphabetic characters
+/// Rule where the input `String` contains only alphabet characters
 pub struct AlphabetRule;
 
 impl Rule for AlphabetRule {

src/rule/string/digit.rs

@@ -3,7 +3,9 @@ use crate::rule::Rule;
 use crate::Refined;
 use regex::Regex;
 
+/// A type that holds a value satisfying the `DigitRule`
 pub type Digit = Refined<DigitRule>;
+/// Rule where the input `String` contains only digit characters
 pub struct DigitRule;
 
 impl Rule for DigitRule {

src/rule/string/email.rs

@@ -3,7 +3,7 @@ use crate::rule::Rule;
 use crate::Refined;
 use regex::Regex;
 
-/// The `Email` type represents a type that conforms to the format of an Email.
+/// A type that holds a value satisfying the `EmailRule`
 ///
 /// # Example
 /// ```rust
@@ -17,6 +17,7 @@ use regex::Regex;
 /// ```
 pub type Email = Refined<EmailRule>;
 
+/// Rule where the input `String` is a valid email format
 pub struct EmailRule;
 
 impl Rule for EmailRule {