chore: cleanup unused imports

Cargo.lock

@@ -4,4 +4,4 @@ version = 3
 
 [[package]]
 name = "estring"
-version = "0.2.1"
+version = "0.3.0"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "estring"
 description = "A simple way to parse a string using type annotations"
-version = "0.2.1"
+version = "0.3.0"
 edition = "2021"
 authors = ["Dmitriy Pleshevskiy <dmitriy@ideascup.me>"]
 readme = "README.md"
@@ -28,7 +28,7 @@ maintenance = { status = "actively-developed" }
 
 [[example]]
 name = "calc"
-required-features = ["structs"]
+required-features = ["structs", "aggs"]
 
 [[example]]
 name = "dotenv"

README.md

@@ -7,7 +7,7 @@
 
 ```toml
 [dependencies]
-estring = "0.2"
+estring = "0.3"
 ```
 
 A simple way to parse a string using type annotations.
@@ -24,6 +24,23 @@ For more details, see [examples].
 
 ## Usage
 
+Basic
+
+```rust
+use estring::EString;
+
+fn main() -> estring::Result<()> {
+    let res: i32 = EString::from("10").parse()?;
+    assert_eq!(res, 10);
+    Ok(())
+}
+```
+
+You can use predefined structs like `SepVec` if you enable the `structs`
+feature.
+
+Note: You can use custom types as annotations! Just implement `ParseFragment`!
+
 ```rust
 use estring::{SepVec, EString};
 
@@ -42,8 +59,23 @@ fn main() -> estring::Result<()> {
 }
 ```
 
-You can use custom types as annotations! Just implement
-`estring::ParseFragment`!
+You can also use predefined aggregators if you enable the `aggs` feature.
+
+```rust
+use estring::{Aggregate, EString, Product, SepVec, Sum};
+
+type PlusVec<T> = SepVec<T, '+'>;
+type MulVec<T> = SepVec<T, '*'>;
+
+fn main() -> estring::Result<()> {
+    let res = EString::from("10+5*2+3")
+        .parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
+        .agg();
+
+    assert_eq!(res, 23.0);
+    Ok(())
+}
+```
 
 ## Contact Us
 

examples/calc.rs

@@ -1,14 +1,12 @@
-use estring::{EString, SepVec};
+use estring::{Aggregate, EString, Product, SepVec, Sum};
 
 type PlusVec<T> = SepVec<T, '+'>;
 type MulVec<T> = SepVec<T, '*'>;
 
 fn main() -> estring::Result<()> {
     let res = EString::from("10+5*2+3")
-        .parse::<PlusVec<MulVec<f32>>>()?
-        .iter()
-        .map(|m| m.iter().product::<f32>())
-        .sum::<f32>();
+        .parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
+        .agg();
 
     assert_eq!(res, 23.0);
     Ok(())

src/agg.rs

@@ -1,6 +1,8 @@
 //! This module will contain aggregate functions (Sum, Product, etc)
 //!
 
+mod product;
 mod sum;
 
+pub use product::*;
 pub use sum::*;

src/agg/product.rs

@@ -0,0 +1,92 @@
+use crate::{Aggregatable, Aggregate, EString, ParseFragment};
+
+/// Aggregate struct, that can multiply inner aggregatable [items](Aggregatable::items) if
+/// [``Aggregatable::Item``] implements [``std::iter::Product``](std::iter::Product)
+///
+/// # Examples
+///
+/// ```rust
+/// use estring::{Aggregate, EString, SepVec, Product};
+/// let res = EString::from("1*2*3*4")
+///     .parse::<Product<SepVec<i32, '*'>>>()
+///     .unwrap()
+///     .agg();
+/// assert_eq!(res, 24);
+/// ```
+#[derive(Debug, PartialEq, Eq)]
+pub struct Product<T>(pub T);
+
+impl<T> ParseFragment for Product<T>
+where
+    T: ParseFragment,
+{
+    fn parse_frag(es: EString) -> crate::Result<Self> {
+        T::parse_frag(es).map(Self)
+    }
+}
+
+impl<R, T> Aggregate for Product<T>
+where
+    R: std::iter::Product,
+    T: Aggregatable<Item = R>,
+{
+    type Target = R;
+
+    fn agg(self) -> Self::Target {
+        self.0.items().into_iter().product()
+    }
+}
+
+impl<R, T> Aggregatable for Product<T>
+where
+    R: std::iter::Product,
+    T: Aggregatable<Item = R>,
+{
+    type Item = R;
+
+    fn items(self) -> Vec<Self::Item> {
+        vec![self.agg()]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::SepVec;
+
+    use super::*;
+
+    type CommaVec<T> = SepVec<T, ','>;
+    type MulVec<T> = SepVec<T, '*'>;
+
+    #[test]
+    fn should_parse_vec() {
+        let es = EString::from("1,2,3");
+        match es.parse::<Product<CommaVec<i32>>>() {
+            Ok(res) => assert_eq!(res, Product(CommaVec::from(vec![1, 2, 3]))),
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn should_aggregate_vector() {
+        let es = EString::from("1,2,3");
+        let expr = es.parse::<Product<CommaVec<i32>>>().unwrap();
+        assert_eq!(expr.agg(), 6);
+    }
+
+    #[test]
+    fn should_aggregate_vector_with_inner_vector() {
+        let es = EString::from("1*2,2,3");
+        let expr = es.parse::<Product<CommaVec<MulVec<i32>>>>().unwrap();
+        assert_eq!(expr.agg(), 12);
+    }
+
+    #[test]
+    fn should_aggregate_vector_with_inner_aggregation() {
+        let es = EString::from("1*2,2,3");
+        let expr = es
+            .parse::<Product<CommaVec<Product<MulVec<i32>>>>>()
+            .unwrap();
+        assert_eq!(expr.agg(), 12);
+    }
+}

src/agg/sum.rs

@@ -1,26 +1,31 @@
-use std::marker::PhantomData;
-
 use crate::{Aggregatable, Aggregate, EString, ParseFragment};
 
+/// Aggregate struct, that can sum inner aggregatable [items](Aggregatable::items) if
+/// [``Aggregatable::Item``] implements [``std::iter::Sum``](std::iter::Sum)
+///
+/// # Examples
+///
+/// ```rust
+/// use estring::{Aggregate, EString, SepVec, Sum};
+/// let res = EString::from("1+2+3+4")
+///     .parse::<Sum<SepVec<i32, '+'>>>()
+///     .unwrap()
+///     .agg();
+/// assert_eq!(res, 10);
+/// ```
 #[derive(Debug, PartialEq, Eq)]
-struct Sum<R, T>(T, PhantomData<R>);
+pub struct Sum<T>(pub T);
 
-impl<R, T> Sum<R, T> {
-    fn new(inner: T) -> Self {
-        Self(inner, PhantomData::default())
-    }
-}
-
-impl<R, T> ParseFragment for Sum<R, T>
+impl<T> ParseFragment for Sum<T>
 where
     T: ParseFragment,
 {
     fn parse_frag(es: EString) -> crate::Result<Self> {
-        T::parse_frag(es).map(Self::new)
+        T::parse_frag(es).map(Self)
     }
 }
 
-impl<R, T> Aggregate for Sum<R, T>
+impl<R, T> Aggregate for Sum<T>
 where
     R: std::iter::Sum,
     T: Aggregatable<Item = R>,
@@ -32,7 +37,7 @@ where
     }
 }
 
-impl<R, T> Aggregatable for Sum<R, T>
+impl<R, T> Aggregatable for Sum<T>
 where
     R: std::iter::Sum,
     T: Aggregatable<Item = R>,
@@ -56,8 +61,8 @@ mod tests {
     #[test]
     fn should_parse_vec() {
         let es = EString::from("1,2,3");
-        match es.parse::<Sum<i32, CommaVec<i32>>>() {
-            Ok(res) => assert_eq!(res, Sum::new(CommaVec::from(vec![1, 2, 3]))),
+        match es.parse::<Sum<CommaVec<i32>>>() {
+            Ok(res) => assert_eq!(res, Sum(CommaVec::from(vec![1, 2, 3]))),
             _ => unreachable!(),
         }
     }
@@ -65,23 +70,21 @@ mod tests {
     #[test]
     fn should_aggregate_vector() {
         let es = EString::from("1,2,3");
-        let expr = es.parse::<Sum<i32, CommaVec<i32>>>().unwrap();
+        let expr = es.parse::<Sum<CommaVec<i32>>>().unwrap();
         assert_eq!(expr.agg(), 6);
     }
 
     #[test]
     fn should_aggregate_vector_with_inner_vector() {
         let es = EString::from("1+2,2,3");
-        let expr = es.parse::<Sum<i32, CommaVec<PlusVec<i32>>>>().unwrap();
+        let expr = es.parse::<Sum<CommaVec<PlusVec<i32>>>>().unwrap();
         assert_eq!(expr.agg(), 8);
     }
 
     #[test]
     fn should_aggregate_vector_with_inner_aggregation() {
         let es = EString::from("1+2,2,3");
-        let expr = es
-            .parse::<Sum<_, CommaVec<Sum<_, PlusVec<i32>>>>>()
-            .unwrap();
+        let expr = es.parse::<Sum<CommaVec<Sum<PlusVec<i32>>>>>().unwrap();
         assert_eq!(expr.agg(), 8);
     }
 }

src/core.rs

@@ -240,6 +240,7 @@ impl ParseFragment for EString {
     }
 }
 
+#[cfg(feature = "aggs")]
 impl Aggregatable for EString {
     type Item = Self;
 
@@ -263,6 +264,7 @@ impl ToEString for String {
     }
 }
 
+#[cfg(feature = "aggs")]
 impl Aggregatable for String {
     type Item = Self;
 
@@ -286,6 +288,7 @@ impl<'a> ToEString for &'a str {
     }
 }
 
+#[cfg(feature = "aggs")]
 impl<'a> Aggregatable for &'a str {
     type Item = Self;
 

src/lib.rs

@@ -7,7 +7,23 @@
 //!
 //! [enve]: https://github.com/pleshevskiy/enve
 //!
-//! ## Getting started
+//! ## Usage
+//!
+//! Basic
+//!
+//! ```rust
+//! use estring::EString;
+//!
+//! fn main() -> estring::Result<()> {
+//!     let res: i32 = EString::from("10").parse()?;
+//!     assert_eq!(res, 10);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! You can use predefined structs like ``SepVec`` if you enable `structs` feature.
+//!
+//! Note: You can use custom types as annotations! Just implement ``ParseFragment``!
 //!
 //! ```rust
 //! use estring::{SepVec, EString};
@@ -27,6 +43,30 @@
 //! }
 //! ```
 //!
+//! You can also use predefined aggregators if you enable `aggs` feature.
+//!
+//! ```rust
+//! use estring::{Aggregate, EString, Product, SepVec, Sum};
+//!
+//! type PlusVec<T> = SepVec<T, '+'>;
+//! type MulVec<T> = SepVec<T, '*'>;
+//!
+//! fn main() -> estring::Result<()> {
+//!     let res = EString::from("10+5*2+3")
+//!         .parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
+//!         .agg();
+//!
+//!     assert_eq!(res, 23.0);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ---
+//!
+//! For more details, see [examples].
+//!
+//! [examples]: https://github.com/pleshevskiy/estring/tree/main/examples
+//!
 #![deny(clippy::pedantic)]
 #![allow(clippy::module_name_repetitions)]
 #![warn(missing_docs)]

src/std/bool.rs

@@ -1,4 +1,4 @@
-use crate::core::{Aggregatable, EString, ParseFragment, ToEString};
+use crate::core::{EString, ParseFragment, ToEString};
 use crate::error::{Error, Reason};
 
 impl ParseFragment for bool {
@@ -19,7 +19,8 @@ impl ToEString for bool {
     }
 }
 
-impl Aggregatable for bool {
+#[cfg(feature = "aggs")]
+impl crate::core::Aggregatable for bool {
     type Item = Self;
 
     #[inline]

src/std/number.rs

@@ -1,4 +1,4 @@
-use crate::core::{Aggregatable, EString, ParseFragment, ToEString};
+use crate::core::{EString, ParseFragment, ToEString};
 use crate::error::{Error, Reason};
 
 #[doc(hidden)]
@@ -19,7 +19,8 @@ macro_rules! from_env_string_numbers_impl {
                 }
             }
 
-            impl Aggregatable for $ty {
+            #[cfg(feature = "aggs")]
+            impl crate::core::Aggregatable for $ty {
                 type Item = Self;
 
                 #[inline]

src/std/option.rs

@@ -1,4 +1,4 @@
-use crate::core::{Aggregatable, EString, ParseFragment, ToEString};
+use crate::core::{EString, ParseFragment, ToEString};
 
 impl<T> ToEString for Option<T>
 where
@@ -25,9 +25,10 @@ where
     }
 }
 
-impl<T> Aggregatable for Option<T>
+#[cfg(feature = "aggs")]
+impl<T> crate::core::Aggregatable for Option<T>
 where
-    T: Aggregatable,
+    T: crate::core::Aggregatable,
 {
     type Item = T::Item;
 

src/structs/pair.rs

@@ -118,7 +118,7 @@ hello=bar",
     #[test]
     fn should_format_pair() {
         let pair = Pair::<_, '+', _>(1, 2);
-        assert_eq!(pair.clone().to_estring(), EString(String::from("1+2")));
+        assert_eq!(pair.to_estring(), EString(String::from("1+2")));
         let pair_in_pair = Pair::<_, '=', _>(3, pair);
         assert_eq!(pair_in_pair.to_estring(), EString(String::from("3=1+2")));
     }

src/structs/sep_vec.rs

@@ -1,7 +1,7 @@
 //! Contains the implementations to vec type
 //!
 
-use crate::core::{Aggregatable, EString, ParseFragment, ToEString};
+use crate::core::{EString, ParseFragment, ToEString};
 use std::fmt::Write;
 
 /// Wrapper for ``Vec`` to split string by a separator (`SEP`).
@@ -92,9 +92,10 @@ where
     }
 }
 
-impl<T, const SEP: char> Aggregatable for SepVec<T, SEP>
+#[cfg(feature = "aggs")]
+impl<T, const SEP: char> crate::core::Aggregatable for SepVec<T, SEP>
 where
-    T: Aggregatable,
+    T: crate::core::Aggregatable,
 {
     type Item = T::Item;
 
@@ -106,6 +107,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::Aggregatable;
     use crate::Pair;
     use crate::{Error, Reason};