feat(shorthands): add some type aliases

Author: KSXGitHub

src/enclosed/parser.rs

@@ -4,7 +4,7 @@ use derive_more::{Display, Error};
 use split_char_from_str::SplitCharFromStr;
 
 /// Parse a template string whose queries are placed between an opening bracket character and a closing bracket character,
-/// (such as [curly braces](crate::simple_curly_braces)).
+/// (such as [curly braces](crate::simple_curly_braces())).
 #[derive(Debug, Clone, Copy)]
 pub struct EnclosedTemplateParser<EscapeParser, QueryParser> {
     pub config: ParserConfig,

src/lib.rs

@@ -36,7 +36,7 @@
 //! # }
 //! ```
 //!
-//! _see more:_ [`simple_curly_braces`], [`lazy_parse`](crate::TemplateSystem::lazy_parse).
+//! _see more:_ [`mod@simple_curly_braces`], [`lazy_parse`](crate::TemplateSystem::lazy_parse).
 //!
 //! **Example 2:** Eagerly parse template:
 //!
@@ -71,7 +71,7 @@
 //! # }
 //! ```
 //!
-//! _see more:_ [`simple_curly_braces`], [`eager_parse`](crate::TemplateSystem::eager_parse).
+//! _see more:_ [`mod@simple_curly_braces`], [`eager_parse`](crate::TemplateSystem::eager_parse).
 //!
 #![cfg_attr(not(feature = "std"), no_std)]
 

src/shorthands.rs

@@ -1,3 +1,3 @@
-mod simple_curly_braces;
+pub mod simple_curly_braces;
 
-pub use simple_curly_braces::*;
+pub use simple_curly_braces::{simple_curly_braces, SimpleCurlyBraces};

src/shorthands/simple_curly_braces.rs

@@ -1,7 +1,12 @@
 use crate::{
-    enclosed::{self, SimpleEnclosedTemplateSystem, SimpleEscapeParser, SimpleQueryParser},
-    IntoTemplateSystem,
+    enclosed::{
+        self, simple_escape, simple_query, SimpleEnclosedTemplateSystem, SimpleEscapeParser,
+        SimpleQueryParser,
+    },
+    iter::{EagerParseIter, LazyParseIter, ParsedTemplate},
+    EnclosedTemplateParser, IntoTemplateSystem, Template, TemplateApplicationError,
 };
+use core::{convert::Infallible, fmt};
 
 /// Create a simple template of string interpolation with curly braces.
 ///
@@ -44,9 +49,90 @@ use crate::{
 /// assert_eq!(actual, expected);
 /// # }
 /// ```
-pub fn simple_curly_braces<'a>() -> SimpleEnclosedTemplateSystem<'a> {
+pub fn simple_curly_braces<'a>() -> SimpleCurlyBraces<'a> {
     enclosed::Parser::curly_braces()
         .with_escape_parser(SimpleEscapeParser)
         .with_query_parser(SimpleQueryParser)
         .into_template_system()
 }
+
+/// Return type of [`simple_curly_braces`].
+pub type SimpleCurlyBraces<'a> = SimpleEnclosedTemplateSystem<'a>;
+
+/// Return type of [`SimpleCurlyBraces::lazy_parse`].
+pub type LazilyParsed<'a, Query> = Template<
+    LazyParseIter<'a, EnclosedTemplateParser<SimpleEscapeParser, SimpleQueryParser>>,
+    Query,
+>;
+
+pub use LazilyParsed as LazilyParsedTemplate;
+
+#[cfg_attr(
+    feature = "std",
+    doc = r"Error type of [`LazilyParsedTemplate::to_string`] and [`LazilyParsedTemplate::write_to`]."
+)]
+#[cfg_attr(
+    not(feature = "std"),
+    doc = r"Error type of [`LazilyParsedTemplate::write_to`]."
+)]
+pub type LazilyParsedApplicationError<QueryError> = TemplateApplicationError<
+    enclosed::ParseError<simple_escape::ParseError, simple_query::ParseError>,
+    QueryError,
+    fmt::Error,
+>;
+
+/// Value type of [`SimpleCurlyBraces::eager_parse`].
+pub type EagerlyParsed<SegmentContainer, Query> = ParsedTemplate<SegmentContainer, Query>;
+
+/// Error type of [`SimpleCurlyBraces::eager_parse`].
+pub type EagerParseError =
+    enclosed::ParseError<simple_escape::ParseError, simple_query::ParseError>;
+
+/// Return type of [`EagerlyParsed::to_template`].
+pub type EagerlyParsedTemplate<SegmentIter, Query> = Template<EagerParseIter<SegmentIter>, Query>;
+
+#[cfg_attr(
+    feature = "std",
+    doc = r"Error type of [`EagerlyParsedTemplate::to_string`] and [`EagerlyParsedTemplate::write_to`]."
+)]
+#[cfg_attr(
+    not(feature = "std"),
+    doc = r"Error type of [`EagerlyParsedTemplate::write_to`]."
+)]
+pub type EagerlyParsedApplicationError<QueryError> =
+    TemplateApplicationError<Infallible, QueryError, fmt::Error>;
+
+#[cfg(feature = "std")]
+#[cfg(test)]
+mod std_tests {
+    use super::{
+        simple_curly_braces, EagerParseError, EagerlyParsed, EagerlyParsedApplicationError,
+        EagerlyParsedTemplate, LazilyParsed, LazilyParsedApplicationError, SimpleCurlyBraces,
+    };
+    use derive_more::{Display, Error};
+
+    #[test]
+    fn using_type_aliases() {
+        fn _type_check() {
+            #[derive(Debug, Display, Error, Clone, Copy)]
+            enum QueryError {}
+
+            let system: SimpleCurlyBraces<'static> = simple_curly_braces();
+
+            let lazy_parsed_template: LazilyParsed<'_, _> = system.lazy_parse("");
+            let lazy_result: Result<String, LazilyParsedApplicationError<QueryError>> =
+                lazy_parsed_template.to_string(|_| Ok::<_, QueryError>(""));
+            drop(lazy_result);
+
+            let eager_parsed_template: Result<
+                EagerlyParsed<Vec<crate::enclosed::Segment<&str>>, &str>,
+                EagerParseError,
+            > = system.eager_parse::<Vec<_>>("");
+            let eager_parsed_template: EagerlyParsedTemplate<_, &str> =
+                eager_parsed_template.as_ref().unwrap().to_template();
+            let eager_result: Result<String, EagerlyParsedApplicationError<QueryError>> =
+                eager_parsed_template.to_string(|_| Ok::<_, QueryError>(""));
+            drop(eager_result);
+        }
+    }
+}