Merge pull request #32 from tomoikey/v0.5.17

Release V0.5.17

Author: tomoikey

Cargo.toml

@@ -6,7 +6,7 @@ repository = "https://github.com/tomoikey/refined_type"
 readme = "README.md"
 categories = ["accessibility", "development-tools", "rust-patterns"]
 license = "MIT"
-version = "0.5.16"
+version = "0.5.17"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

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

@@ -5,7 +5,7 @@ use crate::rule::{ForAllRule, Rule};
 use crate::Refined;
 
 /// A type that holds a value satisfying the `ExistsRule`
-pub type Exists<RULE, ITERABLE> = Refined<ExistsRule<RULE, ITERABLE, <RULE as Rule>::Item>>;
+pub type Exists<RULE, ITERABLE> = Refined<ExistsRule<RULE, ITERABLE>>;
 
 /// A type that holds a Vec value satisfying the `ExistsRule`
 pub type ExistsVec<RULE> = Refined<ExistsVecRule<RULE>>;
@@ -23,25 +23,22 @@ 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, ITEM> = Not<ForAllRule<Not<RULE>, 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>, <RULE as Rule>::Item>;
+pub type ExistsVecRule<RULE> = ExistsRule<RULE, Vec<<RULE as Rule>::Item>>;
 
 /// Rule where at least one data in the `VecDeque` satisfies the condition
-pub type ExistsVecDequeRule<RULE> =
-    ExistsRule<RULE, VecDeque<<RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ExistsVecDequeRule<RULE> = ExistsRule<RULE, VecDeque<<RULE as Rule>::Item>>;
 
 /// Rule where at least one data in the `HashSet` satisfies the condition
-pub type ExistsHashSetRule<RULE> =
-    ExistsRule<RULE, HashSet<<RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ExistsHashSetRule<RULE> = ExistsRule<RULE, HashSet<<RULE as Rule>::Item>>;
 
 /// Rule where at least one data in the `HashMap` satisfies the condition
-pub type ExistsHashMapRule<K, RULE> =
-    ExistsRule<RULE, HashMap<K, <RULE as Rule>::Item>, <RULE as Rule>::Item>;
+pub type ExistsHashMapRule<K, RULE> = ExistsRule<RULE, HashMap<K, <RULE as Rule>::Item>>;
 
 /// Rule where at least one data in the `String` satisfies the condition
-pub type ExistsStringRule<RULE> = ExistsRule<RULE, String, char>;
+pub type ExistsStringRule<RULE> = ExistsRule<RULE, String>;
 
 #[cfg(test)]
 mod tests {

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/init.rs

@@ -3,29 +3,29 @@ use crate::Refined;
 use std::collections::VecDeque;
 
 /// A type that holds a value satisfying the `InitRule`
-pub type Init<'a, RULE, ITERABLE> = Refined<InitRule<'a, RULE, ITERABLE>>;
+pub type Init<'a, RULE, ITERABLE> = Refined<InitRule<RULE, ITERABLE>>;
 
 /// A type that holds a Vec value satisfying the `InitRule`
-pub type InitVec<'a, RULE> = Refined<InitVecRule<'a, RULE>>;
+pub type InitVec<RULE> = Refined<InitVecRule<RULE>>;
 
 /// A type that holds a VecDeque value satisfying the `InitRule`
-pub type InitVecDeque<'a, RULE> = Refined<InitVecDequeRule<'a, RULE>>;
+pub type InitVecDeque<RULE> = Refined<InitVecDequeRule<RULE>>;
 
 /// A type that holds a String value satisfying the `InitRule`
-pub type InitString<'a, RULE> = Refined<InitStringRule<'a, RULE>>;
+pub type InitString<'a, RULE> = Refined<InitStringRule<RULE>>;
 
 /// Rule that applies to the initialization of a collection
-pub type InitRule<'a, RULE, ITERABLE> =
-    ReverseRule<'a, SkipRule<RULE, ITERABLE, SkipFirst<<ITERABLE as Iterable<'a>>::Item>>>;
+pub type InitRule<RULE, ITERABLE> =
+    ReverseRule<SkipRule<RULE, ITERABLE, SkipFirst<<ITERABLE as Iterable>::Item>>>;
 
 /// Rule that applies to the initialization of a `Vec`
-pub type InitVecRule<'a, RULE> = InitRule<'a, RULE, Vec<<RULE as Rule>::Item>>;
+pub type InitVecRule<RULE> = InitRule<RULE, Vec<<RULE as Rule>::Item>>;
 
 /// Rule that applies to the initialization of a `VecDeque`
-pub type InitVecDequeRule<'a, RULE> = InitRule<'a, RULE, VecDeque<<RULE as Rule>::Item>>;
+pub type InitVecDequeRule<RULE> = InitRule<RULE, VecDeque<<RULE as Rule>::Item>>;
 
 /// Rule that applies to the initialization of a `String`
-pub type InitStringRule<'a, RULE> = InitRule<'a, RULE, String>;
+pub type InitStringRule<RULE> = InitRule<RULE, String>;
 
 #[cfg(test)]
 mod tests {

src/rule/collection/iterable.rs

@@ -1,19 +1,21 @@
 use std::collections::VecDeque;
 
-pub trait Iterable<'a> {
-    type Item: 'a;
+pub trait Iterable {
+    type Item;
 
-    fn into_iterator(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a>;
+    fn into_iterator<'a>(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a>
+    where
+        Self: 'a;
     fn length(&self) -> usize;
 }
 
-impl<'a, T> Iterable<'a> for Vec<T>
-where
-    T: 'a,
-{
+impl<T> Iterable for Vec<T> {
     type Item = T;
 
-    fn into_iterator(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a> {
+    fn into_iterator<'a>(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a>
+    where
+        Self: 'a,
+    {
         Box::new(self.into_iter())
     }
 
@@ -22,13 +24,13 @@ where
     }
 }
 
-impl<'a, T> Iterable<'a> for VecDeque<T>
-where
-    T: 'a,
-{
+impl<T> Iterable for VecDeque<T> {
     type Item = T;
 
-    fn into_iterator(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a> {
+    fn into_iterator<'a>(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a>
+    where
+        Self: 'a,
+    {
         Box::new(self.into_iter())
     }
 
@@ -37,10 +39,13 @@ where
     }
 }
 
-impl<'a> Iterable<'a> for String {
+impl Iterable for String {
     type Item = char;
 
-    fn into_iterator(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a> {
+    fn into_iterator<'a>(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a>
+    where
+        Self: 'a,
+    {
         Box::new(self.chars().collect::<Vec<_>>().into_iter())
     }
 
@@ -49,10 +54,13 @@ impl<'a> Iterable<'a> for String {
     }
 }
 
-impl<'a> Iterable<'a> for &'a str {
+impl<'a> Iterable for &'a str {
     type Item = char;
 
-    fn into_iterator(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'a> {
+    fn into_iterator<'b>(self) -> Box<dyn DoubleEndedIterator<Item = Self::Item> + 'b>
+    where
+        Self: 'b,
+    {
         Box::new(self.chars())
     }
 

src/rule/collection/last.rs

@@ -4,28 +4,28 @@ use crate::rule::{IndexRule, ReverseRule, Rule};
 use crate::Refined;
 
 /// A type that holds a value satisfying the `LastRule`
-pub type Last<'a, RULE, ITERABLE> = Refined<LastRule<'a, RULE, ITERABLE>>;
+pub type Last<RULE, ITERABLE> = Refined<LastRule<RULE, ITERABLE>>;
 
 /// A type that holds a Vec value satisfying the `LastRule`
-pub type LastVec<'a, RULE> = Refined<LastVecRule<'a, RULE>>;
+pub type LastVec<RULE> = Refined<LastVecRule<RULE>>;
 
 /// A type that holds a VecDeque value satisfying the `LastRule`
-pub type LastVecDeque<'a, RULE> = Refined<LastVecDequeRule<'a, RULE>>;
+pub type LastVecDeque<RULE> = Refined<LastVecDequeRule<RULE>>;
 
 /// A type that holds a String value satisfying the `LastRule`
-pub type LastString<'a, RULE> = Refined<LastStringRule<'a, RULE>>;
+pub type LastString<RULE> = Refined<LastStringRule<RULE>>;
 
 /// Rule where the last element satisfies the condition
-pub type LastRule<'a, RULE, ITERABLE> = ReverseRule<'a, IndexRule<0, RULE, ITERABLE>>;
+pub type LastRule<RULE, ITERABLE> = ReverseRule<IndexRule<0, RULE, ITERABLE>>;
 
 /// Rule where the last element in the `Vec` satisfies the condition
-pub type LastVecRule<'a, RULE> = LastRule<'a, RULE, Vec<<RULE as Rule>::Item>>;
+pub type LastVecRule<RULE> = LastRule<RULE, Vec<<RULE as Rule>::Item>>;
 
 /// Rule where the last element in the `VecDeque` satisfies the condition
-pub type LastVecDequeRule<'a, RULE> = LastRule<'a, RULE, VecDeque<<RULE as Rule>::Item>>;
+pub type LastVecDequeRule<RULE> = LastRule<RULE, VecDeque<<RULE as Rule>::Item>>;
 
 /// Rule where the last element in the `String` satisfies the condition
-pub type LastStringRule<'a, RULE> = LastRule<'a, RULE, String>;
+pub type LastStringRule<RULE> = LastRule<RULE, String>;
 
 #[cfg(test)]
 mod tests {

src/rule/collection/reverse.rs

@@ -4,20 +4,20 @@ use crate::Refined;
 use std::marker::PhantomData;
 
 /// A type that holds a value satisfying the `ReverseRule`
-pub type Reverse<'a, RULE> = Refined<ReverseRule<'a, RULE>>;
+pub type Reverse<RULE> = Refined<ReverseRule<RULE>>;
 
 /// Rule where the data in the collection satisfies the condition after reversing
-pub struct ReverseRule<'a, RULE>
+pub struct ReverseRule<RULE>
 where
     RULE: Rule,
 {
-    _phantom_data: PhantomData<&'a RULE>,
+    _phantom_data: PhantomData<RULE>,
 }
 
-impl<'a, RULE, ITERABLE> Rule for ReverseRule<'a, RULE>
+impl<RULE, ITERABLE> Rule for ReverseRule<RULE>
 where
     RULE: Rule<Item = ITERABLE>,
-    ITERABLE: Iterable<'a> + FromIterator<ITERABLE::Item>,
+    ITERABLE: Iterable + FromIterator<ITERABLE::Item>,
 {
     type Item = RULE::Item;
 

src/rule/collection/skip.rs

@@ -29,10 +29,10 @@ where
     _phantom_data: PhantomData<(RULE, ITERABLE, OPTION)>,
 }
 
-impl<'a, RULE, ITERABLE, OPTION> Rule for SkipRule<RULE, ITERABLE, OPTION>
+impl<RULE, ITERABLE, OPTION> Rule for SkipRule<RULE, ITERABLE, OPTION>
 where
     RULE: Rule,
-    ITERABLE: Iterable<'a, Item = RULE::Item> + FromIterator<RULE::Item>,
+    ITERABLE: Iterable<Item = RULE::Item> + FromIterator<RULE::Item>,
     OPTION: SkipOption<Item = RULE::Item>,
 {
     type Item = ITERABLE;