add rust doc

Author: tomoikey

src/rule/length/equal.rs

@@ -1,10 +1,25 @@
 #[macro_export]
-macro_rules! length_equal_rule {
+macro_rules! length_equal {
     ($length:literal) => {
         paste::item! {
+            /// A type that holds a value satisfying the LengthEqualN rule.
+            /// # Example
+            /// ```rust
+            /// use refined_type::length_equal;
+            /// length_equal!(5);
+            ///
+            /// let target = "12345";
+            /// let refined = LengthEqual5::new(target).unwrap();
+            /// assert_eq!(refined.into_value(), "12345");
+            ///
+            /// let target = "1234";
+            /// let refined = LengthEqual5::new(target);
+            /// assert!(refined.is_err());
+            /// ```
             #[allow(dead_code)]
             pub type [<LengthEqual $length>]<ITEM> = $crate::Refined<[<LengthEqualRule $length>]<ITEM>>;
 
+            /// Rule where the length of the input value is equal to N
             #[allow(dead_code)]
             pub struct [<LengthEqualRule $length>]<ITEM> {
                 _phantom: ::std::marker::PhantomData<ITEM>,
@@ -23,16 +38,16 @@ macro_rules! length_equal_rule {
         }
     };
     ($length:literal, $($lengths:literal),+) => {
-        length_equal_rule!($length);
-        length_equal_rule!($($lengths),+);
+        length_equal!($length);
+        length_equal!($($lengths),+);
     };
 }
 
 #[cfg(test)]
 mod tests {
     use crate::result::Error;
 
-    length_equal_rule!(5, 10);
+    length_equal!(5, 10);
 
     #[test]
     fn test_length_equal_5() -> Result<(), Error> {

src/rule/length/grater.rs

@@ -2,9 +2,23 @@
 macro_rules! length_greater_than {
     ($length:literal) => {
         paste::item! {
+            /// A type that holds a value satisfying the LengthGreaterThanN rule.
+            /// # Example
+            /// ```rust
+            /// use refined_type::length_greater_than;
+            /// length_greater_than!(5);
+            ///
+            /// let target = "123456";
+            /// let refined = LengthGreaterThan5::new(target).unwrap();
+            /// assert_eq!(refined.into_value(), "123456");
+            ///
+            /// let target = "12345";
+            /// let refined = LengthGreaterThan5::new(target);
+            /// assert!(refined.is_err());
             #[allow(dead_code)]
             pub type [<LengthGreaterThan $length>]<ITEM> = $crate::Refined<[<LengthGreaterThanRule $length>]<ITEM>>;
 
+            /// Rule where the length of the input value is greater than N
             #[allow(dead_code)]
             pub struct [<LengthGreaterThanRule $length>]<ITEM> {
                 _phantom: ::std::marker::PhantomData<ITEM>,

src/rule/length/length_definition.rs

@@ -1,3 +1,10 @@
+/// This trait is used to define the length of the target.
+/// # Example
+/// ```rust
+/// use refined_type::rule::LengthDefinition;
+/// let target = "12345";
+/// assert_eq!(target.length(), 5);
+/// ```
 pub trait LengthDefinition {
     fn length(&self) -> usize;
 }

src/rule/length/less.rs

@@ -2,9 +2,24 @@
 macro_rules! length_less_than {
     ($length:literal) => {
         paste::item! {
+            /// A type that holds a value satisfying the LengthLessThanN rule.
+            /// # Example
+            /// ```rust
+            /// use refined_type::length_less_than;
+            /// length_less_than!(5);
+            ///
+            /// let target = "1234";
+            /// let refined = LengthLessThan5::new(target).unwrap();
+            /// assert_eq!(refined.into_value(), "1234");
+            ///
+            /// let target = "12345";
+            /// let refined = LengthLessThan5::new(target);
+            /// assert!(refined.is_err());
+            /// ```
             #[allow(dead_code)]
             pub type [<LengthLessThan $length>]<ITEM> = $crate::Refined<[<LengthLessThanRule $length>]<ITEM>>;
 
+            /// Rule where the length of the input value is less than N
             #[allow(dead_code)]
             pub struct [<LengthLessThanRule $length>]<ITEM> {
                 _phantom: ::std::marker::PhantomData<ITEM>,