Renamed 'lexers' to parsers, as to my knowledge, these would just be subparsers

within a parser (whereas lexers would happen before parsing starts, and would be
about reducing text into a smaller set of lexemes blah blah blah -- thing is, I
hate pedantry [what's that you say, how long is this commit going to get?] and
there might be some viable stretching of the word to actually make this correct.
But I figure I'll have to hear someone else be pedantic about it so I'm going to
change it anyways and write the worst commit you've ever seen in quiet
retribution.  Well, not really quiet.  RIP Zyzz. 'Second line is not empty, are
you' yea shut up.

Author: Tko1

src/reader.rs

@@ -249,14 +249,14 @@ pub fn integer_parser(input: &str) -> IResult<&str, i32> {
     );
     // integer_tail<&str,&str> above function 
 
-    named!(integer_lexer <&str, String>,
+    named!(integer_parser <&str, String>,
          do_parse!(
              sign: integer_sign >>
              rest_input: integer_tail >>
              (format!("{}{}",sign,rest_input))
          )
     );
-    integer_lexer(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
+    integer_parser(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
 }
 
 /// Parses valid doubles
@@ -266,15 +266,15 @@ pub fn integer_parser(input: &str) -> IResult<&str, i32> {
 pub fn double_parser(input: &str) -> IResult<&str, f64> {
     named!(decimal_point<&str, &str>, take_while_m_n!(1, 1, is_period_char));
 
-    named!(double_lexer <&str, String>,
+    named!(double_parser <&str, String>,
          do_parse!(
              integer: integer_parser >> //integer_part >>
              point: complete!(decimal_point) >>
              decimal: integer_tail >> //decimal_part >>
              (format!("{}{}{}",integer, point, decimal))
          )
     );
-    double_lexer(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
+    double_parser(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
 }
 // Currently used to create 'try_readers', which are readers (or
 // reader functions, at least) that are basically composable InputType