Rename back to Parser, simplify sample code a bit.

src/lib.rs

@@ -34,18 +34,14 @@
 //! First, you'll want to construct a parser:
 //!
 //! ```
-//! use humanize::HumanizedParser;
-//!
-//! let parser = HumanizedParser::new();
+//! let parser = humanize::Parser::new();
 //! ```
 //!
 //! Then, you can use that parser to examine some input. In the typical
 //! case, you can invoke a type-specific parse method like `parse_boolean`.
 //!
 //! ```
-//! # use humanize::HumanizedParser;
-//! #
-//! # let parser = HumanizedParser::new();
+//! let parser = humanize::Parser::new();
 //! let enabled = parser.parse_boolean("on").unwrap_or(false);
 //! assert_eq!(enabled, true);
 //! ```
@@ -75,4 +71,4 @@ extern crate language_tags;
 pub mod matchers;
 mod parser;
 
-pub use parser::HumanizedParser;
+pub use parser::Parser;

src/matchers/english/boolean.rs

@@ -10,13 +10,13 @@
 // much better and actually work correctly. :)
 
 use matchers::*;
-use parser::HumanizedParser;
+use parser::Parser;
 
 /// Register matchers for English expressions for boolean values.
 ///
 /// This doesn't need to be invoked directly typically. This will
 /// be called by `humanize::matchers::english::register`.
-pub fn register(parser: &mut HumanizedParser) {
+pub fn register(parser: &mut Parser) {
     parser.register_matcher(Matcher {
         name: "English Booleans",
         language: langtag!(en),

src/matchers/english/mod.rs

@@ -6,15 +6,15 @@
 
 //! English Humanization
 
-use parser::HumanizedParser;
+use parser::Parser;
 
 pub mod boolean;
 // pub mod ordinal;
 
 /// Register all of the English language matchers.
 ///
 /// This doesn't need to be invoked directly typically. This will
-/// be called when creating a default `HumanizedParser`.
-pub fn register(parser: &mut HumanizedParser) {
+/// be called when creating a default `Parser`.
+pub fn register(parser: &mut Parser) {
     boolean::register(parser);
 }

src/matchers/mod.rs

@@ -44,7 +44,7 @@ pub enum HumanValue {
 /// A `Match` result is obtained by calling [`parse`] on
 /// some input text. They are created by [`Matcher`]s.
 ///
-/// [`parse`]: ../struct.HumanizedParser.html#method.parse
+/// [`parse`]: ../struct.Parser.html#method.parse
 /// [`Matcher`]: struct.Matcher.html
 #[derive(Debug)]
 pub struct Match {

src/parser.rs

@@ -13,25 +13,25 @@ use matchers::*;
 /// by default when the parser is created. A parser without pre-installed
 /// matchers can be created with `new_without_default_matchers`. Additional
 /// or custom matchers can be added with `register_matcher`.
-pub struct HumanizedParser<'p> {
+pub struct Parser<'p> {
     /// The matchers which have been registered with this parser.
     ///
-    /// Use `HumanizedParser.register_matcher` to add a new matcher.
+    /// Use `Parser.register_matcher` to add a new matcher.
     matchers: Vec<Matcher<'p>>,
 
     /// The language being supported by this parser.
     language: LanguageTag,
 }
 
-impl<'p> HumanizedParser<'p> {
+impl<'p> Parser<'p> {
     /// Construct a new parser, including the default matchers.
     pub fn new() -> Self {
         Default::default()
     }
 
     /// Construct a new parser, but without any of the default matchers.
     pub fn new_without_default_matchers() -> Self {
-        HumanizedParser {
+        Parser {
             matchers: vec![],
             language: Default::default(),
         }
@@ -84,9 +84,9 @@ impl<'p> HumanizedParser<'p> {
     }
 }
 
-impl<'p> Default for HumanizedParser<'p> {
+impl<'p> Default for Parser<'p> {
     fn default() -> Self {
-        let mut p = HumanizedParser {
+        let mut p = Parser {
             matchers: vec![],
             language: Default::default(),
         };