From 29229c400257834d1d59b2cf53e7ce8f5c8a23dd Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 20 Feb 2019 17:36:34 +0100
Subject: [PATCH] =?UTF-8?q?Implement=20parsing=20trait=20for=20str=20?=
 =?UTF-8?q?=E2=99=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/doc.rs     |  6 +++---
 src/lib.rs     |  8 +++-----
 src/parsing.rs | 25 +++++++++++++++++--------
 src/pdf.rs     |  6 ++----
 4 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/src/doc.rs b/src/doc.rs
index a6d4b6891..8ba268351 100644
--- a/src/doc.rs
+++ b/src/doc.rs
@@ -172,16 +172,16 @@ impl<'s> Generator<'s> {
 #[cfg(test)]
 mod generator_tests {
     use super::*;
-    use crate::parsing::{Tokenize, Parse};
+    use crate::parsing::ParseTree;
 
     /// Test if the source gets generated into the document.
     fn test(src: &str, doc: Document) {
-        assert_eq!(src.tokenize().parse().unwrap().generate(), Ok(doc));
+        assert_eq!(src.parse_tree().unwrap().generate(), Ok(doc));
     }
 
     /// Test if generation gives this error for the source code.
     fn test_err(src: &str, err: GenerationError) {
-        assert_eq!(src.tokenize().parse().unwrap().generate(), Err(err));
+        assert_eq!(src.parse_tree().unwrap().generate(), Err(err));
     }
 
     #[test]
diff --git a/src/lib.rs b/src/lib.rs
index b09a63359..7e875d3ee 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,17 +5,15 @@
 //! # Example
 //! This is an example of compiling a _really_ simple document into _PDF_.
 //! ```
-//! use typeset::{parsing::{Tokenize, Parse}, doc::Generate, export::WritePdf};
+//! use typeset::{parsing::ParseTree, doc::Generate, export::WritePdf};
 //!
 //! let path = "hello-typeset.pdf";
 //! # let path = "../target/hello-typeset.pdf";
 //! let mut file = std::fs::File::create(path).unwrap();
 //!
-//! // Tokenize, parse and then generate the document.
+//! // Parse the source and then generate the document.
 //! let src = "Hello World from Typeset!";
-//! let doc = src.tokenize()
-//!     .parse().unwrap()
-//!     .generate().unwrap();
+//! let doc = src.parse_tree().unwrap().generate().unwrap();
 //!
 //! file.write_pdf(&doc).unwrap();
 //! ```
diff --git a/src/parsing.rs b/src/parsing.rs
index 173a5ba63..270d8551c 100644
--- a/src/parsing.rs
+++ b/src/parsing.rs
@@ -298,19 +298,28 @@ pub struct Function<'s> {
 
 
 /// A type that is parsable into a syntax tree.
-pub trait Parse<'s> {
+pub trait ParseTree<'s> {
     /// Parse self into a syntax tree.
-    fn parse(self) -> ParseResult<SyntaxTree<'s>>;
+    fn parse_tree(self) -> ParseResult<SyntaxTree<'s>>;
 }
 
-impl<'s> Parse<'s> for Tokens<'s> {
-    fn parse(self) -> ParseResult<SyntaxTree<'s>> {
+impl<'s> ParseTree<'s> for &'s str {
+    #[inline]
+    fn parse_tree(self) -> ParseResult<SyntaxTree<'s>> {
+        self.tokenize().parse_tree()
+    }
+}
+
+impl<'s> ParseTree<'s> for Tokens<'s> {
+    #[inline]
+    fn parse_tree(self) -> ParseResult<SyntaxTree<'s>> {
         Parser::new(self).parse()
     }
 }
 
-impl<'s> Parse<'s> for Vec<Token<'s>> {
-    fn parse(self) -> ParseResult<SyntaxTree<'s>> {
+impl<'s> ParseTree<'s> for Vec<Token<'s>> {
+    #[inline]
+    fn parse_tree(self) -> ParseResult<SyntaxTree<'s>> {
         Parser::new(self.into_iter()).parse()
     }
 }
@@ -594,12 +603,12 @@ mod parse_tests {
 
     /// Test if the source code parses into the syntax tree.
     fn test(src: &str, tree: SyntaxTree) {
-        assert_eq!(src.tokenize().parse(), Ok(tree));
+        assert_eq!(src.parse_tree(), Ok(tree));
     }
 
     /// Test if the source parses into the error.
     fn test_err(src: &str, err: ParseError) {
-        assert_eq!(src.tokenize().parse(), Err(err));
+        assert_eq!(src.parse_tree(), Err(err));
     }
 
     /// Short cut macro to create a syntax tree.
diff --git a/src/pdf.rs b/src/pdf.rs
index e15cc33f2..b4d0c41a6 100644
--- a/src/pdf.rs
+++ b/src/pdf.rs
@@ -101,15 +101,13 @@ impl<W: Write> WritePdf<Document> for W {
 #[cfg(test)]
 mod pdf_tests {
     use super::*;
-    use crate::parsing::{Tokenize, Parse};
+    use crate::parsing::ParseTree;
     use crate::doc::Generate;
 
     /// Create a pdf with a name from the source code.
     fn test(name: &str, src: &str) {
         let mut file = std::fs::File::create(format!("../target/{}", name)).unwrap();
-        let doc = src.tokenize()
-            .parse().unwrap()
-            .generate().unwrap();
+        let doc = src.parse_tree().unwrap().generate().unwrap();
         file.write_pdf(&doc).unwrap();
     }