Merge pull request #30 from tomoikey/feat/doc_comment

add doc comments

Author: tomoikey

src/refined.rs

@@ -57,6 +57,28 @@ impl<RULE, T> Refined<RULE>
 where
     RULE: Rule<Item = T>,
 {
+    /// Creates a new `Refined` instance if the provided value satisfies the rule.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The value to be refined.
+    ///
+    /// # Returns
+    ///
+    /// * `Result<Self, Error<T>>` - A `Refined` instance if the value satisfies the rule, otherwise an error.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use refined_type::rule::NonEmptyStringRule;
+    /// use refined_type::Refined;
+    ///
+    /// let non_empty_string = Refined::<NonEmptyStringRule>::new("Hello".to_string());
+    /// assert!(non_empty_string.is_ok());
+    ///
+    /// let empty_string = Refined::<NonEmptyStringRule>::new("".to_string());
+    /// assert!(empty_string.is_err());
+    /// ```
     pub fn new(value: T) -> Result<Self, Error<T>> {
         let value = RULE::validate(value).map_err(|e| {
             let message = e.to_string();
@@ -65,6 +87,28 @@ where
         Ok(Self { value })
     }
 
+    /// Creates a new `Refined` instance if the provided value satisfies the rule.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The value to be refined.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the value does not satisfy the rule.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use refined_type::rule::NonEmptyStringRule;
+    /// use refined_type::Refined;
+    ///
+    /// let non_empty_string = Refined::<NonEmptyStringRule>::unsafe_new("Hello".to_string());
+    /// assert_eq!(non_empty_string.into_value(), "Hello");
+    ///
+    /// // This will panic
+    /// // let empty_string = Refined::<NonEmptyStringRule>::unsafe_new("".to_string());
+    /// ```
     pub fn unsafe_new(value: T) -> Self
     where
         T: Debug,
@@ -118,10 +162,40 @@ where
         Refined::new(f(self.into_value()))
     }
 
+    /// Returns a reference to the value inside the `Refined` type.
+    ///
+    /// # Returns
+    ///
+    /// * `&RULE::Item` - A reference to the value inside the `Refined` type.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use refined_type::rule::NonEmptyStringRule;
+    /// use refined_type::Refined;
+    ///
+    /// let non_empty_string = Refined::<NonEmptyStringRule>::new("Hello".to_string()).unwrap();
+    /// assert_eq!(non_empty_string.value(), "Hello");
+    /// ```
     pub fn value(&self) -> &RULE::Item {
         &self.value
     }
 
+    /// Consumes the `Refined` instance and returns the inner value.
+    ///
+    /// # Returns
+    ///
+    /// * `RULE::Item` - The value inside the `Refined` type.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use refined_type::rule::NonEmptyStringRule;
+    /// use refined_type::Refined;
+    ///
+    /// let non_empty_string = Refined::<NonEmptyStringRule>::new("Hello".to_string()).unwrap();
+    /// assert_eq!(non_empty_string.into_value(), "Hello");
+    /// ```
     pub fn into_value(self) -> RULE::Item {
         self.value
     }

src/rule/collection/exists.rs

@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 
 use crate::rule::composer::Not;
-use crate::rule::{ForAllRule, Iterable, Rule};
+use crate::rule::{ForAllRule, Rule};
 use crate::Refined;
 
 /// A type that holds a value satisfying the `ExistsRule`
@@ -23,8 +23,7 @@ pub type ExistsHashMap<K, RULE> = Refined<ExistsHashMapRule<K, RULE>>;
 pub type ExistsString<RULE> = Refined<ExistsStringRule<RULE>>;
 
 /// Rule where at least one data in the collection satisfies the condition
-pub type ExistsRule<RULE, ITERABLE> =
-    Not<ForAllRule<Not<RULE>, ITERABLE, <ITERABLE as Iterable>::Item>>;
+pub type ExistsRule<RULE, ITERABLE> = Not<ForAllRule<Not<RULE>, ITERABLE>>;
 
 /// Rule where at least one data in the `Vec` satisfies the condition
 pub type ExistsVecRule<RULE> = ExistsRule<RULE, Vec<<RULE as Rule>::Item>>;

src/rule/collection/for_all.rs

@@ -1,10 +1,10 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 
-use crate::rule::{NoSkip, Rule, SkipRule};
+use crate::rule::{Iterable, NoSkip, Rule, SkipRule};
 use crate::Refined;
 
 /// A type that holds a value satisfying the `ForAllRule`
-pub type ForAll<RULE, ITERABLE, ITEM> = Refined<ForAllRule<RULE, ITERABLE, ITEM>>;
+pub type ForAll<RULE, ITERABLE> = Refined<ForAllRule<RULE, ITERABLE>>;
 
 /// A type that holds a Vec value satisfying the `ForAllRule`
 pub type ForAllVec<RULE> = Refined<ForAllVecRule<RULE>>;
@@ -22,25 +22,23 @@ pub type ForAllHashMap<K, RULE> = Refined<ForAllHashMapRule<K, RULE>>;
 pub type ForAllString<RULE> = Refined<ForAllStringRule<RULE>>;
 
 /// Rule where all the data in the collection satisfies the condition
-pub type ForAllRule<RULE, ITERABLE, ITEM> = SkipRule<RULE, ITERABLE, NoSkip<ITEM>>;
+pub type ForAllRule<RULE, ITERABLE> =
+    SkipRule<RULE, ITERABLE, NoSkip<<ITERABLE as Iterable>::Item>>;
 
 /// Rule where all the data in the `Vec` satisfies the condition
-pub type ForAllVecRule<RULE> = ForAllRule<RULE, Vec<<RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ForAllVecRule<RULE> = ForAllRule<RULE, Vec<<RULE as Rule>::Item>>;
 
 /// Rule where all the data in the `VecDeque` satisfies the condition
-pub type ForAllVecDequeRule<RULE> =
-    ForAllRule<RULE, VecDeque<<RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ForAllVecDequeRule<RULE> = ForAllRule<RULE, VecDeque<<RULE as Rule>::Item>>;
 
 /// Rule where all the data in the `HashSet` satisfies the condition
-pub type ForAllHashSetRule<RULE> =
-    ForAllRule<RULE, HashSet<<RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ForAllHashSetRule<RULE> = ForAllRule<RULE, HashSet<<RULE as Rule>::Item>>;
 
 /// Rule where all the data in the `HashMap` satisfies the condition
-pub type ForAllHashMapRule<K, RULE> =
-    ForAllRule<RULE, HashMap<K, <RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ForAllHashMapRule<K, RULE> = ForAllRule<RULE, HashMap<K, <RULE as Rule>::Item>>;
 
 /// Rule where all the data in the `String` satisfies the condition
-pub type ForAllStringRule<RULE> = ForAllRule<RULE, String, char>;
+pub type ForAllStringRule<RULE> = ForAllRule<RULE, String>;
 
 #[cfg(test)]
 mod tests {

src/rule/collection/reverse.rs

@@ -4,7 +4,7 @@ use crate::Refined;
 use std::marker::PhantomData;
 
 /// A type that holds a value satisfying the `ReverseRule`
-pub type Reverse<'a, RULE> = Refined<ReverseRule<RULE>>;
+pub type Reverse<RULE> = Refined<ReverseRule<RULE>>;
 
 /// Rule where the data in the collection satisfies the condition after reversing
 pub struct ReverseRule<RULE>