update description

Author: tomoikey

src/rule/number/equal.rs

@@ -2,6 +2,7 @@
 macro_rules! equal_rule {
     (($e: literal, $t: ty)) => {
         paste::item! {
+            /// `Equal[N][TYPE]` is a type that indicates that the number is equal to `N`.
             #[allow(dead_code)]
             pub type [<Equal $e $t>] = $crate::Refined<[<EqualRule $e $t>]>;
 

src/rule/number/even.rs

@@ -1,6 +1,7 @@
 macro_rules! even_rule {
     ($t: ty) => {
         paste::item! {
+            /// `Even[TYPE]` is a type that represents that the number is even.
             #[allow(dead_code)]
             pub type [<Even $t:upper>] = $crate::Refined<[<EvenRule $t:upper>]>;
 

src/rule/number/greater.rs

@@ -2,6 +2,7 @@
 macro_rules! greater_rule {
     (($e: literal, $t: ty)) => {
         paste::item! {
+            /// `Greater[N][TYPE]` is a type that indicates that the number is greater than `N`.
             #[allow(dead_code)]
             pub type [<Greater $e $t>] = $crate::Refined<[<GreaterRule $e $t>]>;
 

src/rule/number/less.rs

@@ -2,6 +2,7 @@
 macro_rules! less_rule {
     (($e: literal, $t: ty)) => {
         paste::item! {
+            /// `Less[N][TYPE]` is a type that indicates that the number is less than `N`.
             #[allow(dead_code)]
             pub type [<Less $e $t>] = $crate::Refined<[<LessRule $e $t>]>;
 

src/rule/number/odd.rs

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

src/rule/string/alphabet.rs

@@ -3,6 +3,18 @@ use crate::rule::Rule;
 use crate::Refined;
 use regex::Regex;
 
+/// The `Alphabet` type represents a type that can contain zero or more alphabetic characters.
+///
+/// # Example
+/// ```rust
+/// # use refined_type::rule::Alphabet;
+///
+/// let alphabet_result = Alphabet::new("alphabet".to_string());
+/// assert!(alphabet_result.is_ok());
+///
+/// let alphabet_result = Alphabet::new("I am the 1st".to_string());
+/// assert!(alphabet_result.is_err());
+/// ```
 pub type Alphabet = Refined<AlphabetRule>;
 
 /// A string consisting entirely of alphabetic characters
@@ -26,3 +38,26 @@ impl Rule for AlphabetRule {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::rule::Alphabet;
+
+    #[test]
+    fn test_alphabet_ok_empty() {
+        let alphabet_result = Alphabet::new("".to_string());
+        assert!(alphabet_result.is_ok());
+    }
+
+    #[test]
+    fn test_alphabet_ok_non_empty() {
+        let alphabet_result = Alphabet::new("alphabet".to_string());
+        assert!(alphabet_result.is_ok());
+    }
+
+    #[test]
+    fn test_alphabet_err() {
+        let alphabet_result = Alphabet::new("I am the 1st".to_string());
+        assert!(alphabet_result.is_err());
+    }
+}