update description

Author: tomoikey

src/rule/empty.rs

@@ -8,6 +8,18 @@ use std::iter::Map;
 use std::marker::PhantomData;
 use std::ops::Add;
 
+/// Empty is a type that indicates that its subject is empty.  
+/// The definition of empty is defined by EmptyDefinition.  
+///
+/// # Example
+/// ```rust
+/// # use refined_type::rule::Empty;
+/// let empty_1 = Empty::new(0).unwrap();
+/// let empty_2 = Empty::new(0).unwrap();
+/// let empty = empty_1 + empty_2;
+///
+/// assert_eq!(empty.into_value(), 0);
+/// ```
 pub type Empty<T> = Refined<EmptyRule<T>>;
 
 impl<T> Add for Empty<T>

src/rule/non_empty.rs

@@ -13,6 +13,7 @@ pub use non_empty_map::*;
 pub use non_empty_set::*;
 pub use non_empty_string::*;
 pub use non_empty_vec::*;
+pub use non_empty_vec_deque::*;
 
 pub type NonEmpty<T> = Refined<NonEmptyRule<T>>;
 

src/rule/non_empty/non_empty_map.rs

@@ -5,6 +5,23 @@ use std::collections::hash_map::{IntoKeys, IntoValues, Keys, Values};
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hash, RandomState};
 
+/// `NonEmptyHashMap` is a `HashMap` that follows the `NonEmptyRule`
+/// # Example
+/// ```rust
+/// # use std::collections::{HashMap, HashSet};
+/// # use refined_type::rule::{NonEmptyHashMap, NonEmptyVec};
+/// let mut map = HashMap::new();
+/// map.insert("1", 1);
+/// map.insert("2", 2);
+///
+/// let map = NonEmptyHashMap::new(map).unwrap().insert("3", 3);
+/// let vec: NonEmptyVec<(&str, i32)> = map.into_iter().collect();
+///
+/// assert_eq!(
+///     vec.into_value().into_iter().collect::<HashSet<_>>(),
+///     vec![("1", 1), ("2", 2), ("3", 3)].into_iter().collect()
+/// );
+/// ```
 pub type NonEmptyHashMap<K, V, S = RandomState> = Refined<NonEmptyHashMapRule<K, V, S>>;
 pub type NonEmptyHashMapRule<K, V, S = RandomState> = NonEmptyRule<HashMap<K, V, S>>;
 

src/rule/non_empty/non_empty_set.rs

@@ -6,6 +6,20 @@ use std::collections::hash_set::Difference;
 use std::collections::HashSet;
 use std::hash::{BuildHasher, Hash, RandomState};
 
+/// `NonEmptyHashSet` is a `HashSet` that follows the `NonEmptyRule`
+/// # Example
+/// ```rust
+/// # use std::collections::HashSet;
+/// # use refined_type::rule::NonEmptyHashSet;
+///
+/// let mut set_origin = HashSet::new();
+/// set_origin.insert(1);
+///
+/// let set = NonEmptyHashSet::new(set_origin.clone()).unwrap().insert(2);
+/// set_origin.insert(2);
+///
+/// assert_eq!(set.into_value(), set_origin);
+/// ```
 pub type NonEmptyHashSet<T, S = RandomState> = Refined<NonEmptyRule<HashSet<T, S>>>;
 pub type NonEmptyHashSetRule<T, S = RandomState> = NonEmptyRule<HashSet<T, S>>;
 

src/rule/non_empty/non_empty_string.rs

@@ -5,7 +5,18 @@ use std::ops::Add;
 use std::str::FromStr;
 
 /// This is a predicate type representing a non-empty string
+/// # Example
+/// ```rust
+/// # use refined_type::rule::NonEmptyString;
+///
+/// let non_empty_string_1 = NonEmptyString::new("Hello".to_string()).unwrap();
+/// let non_empty_string_2 = NonEmptyString::new("World".to_string()).unwrap();
+/// let non_empty_string = non_empty_string_1 + non_empty_string_2;
+///
+/// assert_eq!(non_empty_string.into_value(), "HelloWorld");
+/// ```
 pub type NonEmptyString = Refined<NonEmptyStringRule>;
+pub type NonEmptyStringRule = NonEmptyRule<String>;
 
 impl FromStr for NonEmptyString {
     type Err = Error<String>;
@@ -23,8 +34,6 @@ impl Add for NonEmptyString {
     }
 }
 
-pub type NonEmptyStringRule = NonEmptyRule<String>;
-
 #[cfg(test)]
 mod test {
     use crate::rule::{NonEmptyString, NonEmptyStringRule, Rule};

src/rule/non_empty/non_empty_vec.rs

@@ -3,6 +3,15 @@ use crate::Refined;
 
 use std::ops::Add;
 
+/// `NonEmptyHashMap` is a `HashMap` that follows the `NonEmptyRule`
+///
+/// # Example
+/// ```rust
+/// # use refined_type::rule::NonEmptyVec;
+/// let vec = NonEmptyVec::new(vec![1]).unwrap().push(2).push(3);
+///
+/// assert_eq!(vec.into_value(), vec![1, 2, 3]);
+/// ```
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
 pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
 

src/rule/non_empty/non_empty_vec_deque.rs

@@ -3,6 +3,19 @@ use crate::Refined;
 use std::collections::VecDeque;
 use std::ops::Add;
 
+/// `NonEmptyVecDeque` is a `VecDeque` that follows the `NonEmptyRule`
+///
+/// # Example
+/// ```rust
+/// # use std::collections::VecDeque;
+/// # use refined_type::rule::NonEmptyVecDeque;
+///
+/// let mut deque = VecDeque::new();
+/// deque.push_front(1);
+/// let deque = NonEmptyVecDeque::new(deque).unwrap().push_front(2).push_back(3);
+///
+/// assert_eq!(deque.into_value(), vec![2, 1, 3]);
+/// ```
 pub type NonEmptyVecDeque<T> = Refined<NonEmptyVecDequeRule<T>>;
 pub type NonEmptyVecDequeRule<T> = NonEmptyRule<VecDeque<T>>;