Reduce to single error type, remove main

src/compiler.rs

 
 use std::fmt::{Display, Formatter};
 
-use crate::error::CompilerError;
+use crate::error::ElasticError;
 use crate::parser::{Field, Identifier, Select};
 
 #[derive(Debug, PartialEq)]
     }
 }
 
-pub fn compile(expr: Select) -> Result<Query, CompilerError> {
+pub fn compile(expr: Select) -> Result<Query, ElasticError> {
     let field_names: Vec<Value> = expr
         .fields
         .iter()
     use crate::lexer::scan;
     use crate::parser::parse;
 
-    fn _compile(input: &str) -> Result<Query, CompilerError> {
+    fn _compile(input: &str) -> Result<Query, ElasticError> {
         let tokens = scan(input).unwrap();
         let select = parse(tokens).unwrap();
         compile(select)

src/error.rs

 use std::{error::Error, fmt, fmt::Display};
 
 #[derive(Debug, PartialEq)]
-pub struct LexerError {
-    message: String,
+pub struct ElasticError {
+    pub message: String,
 }
 
-impl LexerError {
+impl ElasticError {
     pub fn new(message: &str) -> Self {
         Self {
             message: message.to_string(),
     }
 }
 
-impl Display for LexerError {
+impl Display for ElasticError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", &self.message)
     }
 }
 
-impl Error for LexerError {}
+impl Error for ElasticError {}
 
-impl From<LexerError> for std::io::Error {
-    fn from(e: LexerError) -> Self {
-        Self::new(std::io::ErrorKind::InvalidInput, e.message)
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct ParserError {
-    message: String,
-}
-
-impl ParserError {
-    pub fn new(message: &str) -> Self {
-        Self {
-            message: message.to_string(),
-        }
-    }
-}
-
-impl Display for ParserError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", &self.message)
-    }
-}
-
-impl Error for ParserError {}
-
-impl From<ParserError> for std::io::Error {
-    fn from(e: ParserError) -> Self {
-        Self::new(std::io::ErrorKind::InvalidInput, e.message)
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct CompilerError {
-    message: String,
-}
-
-impl CompilerError {
-    pub fn new(message: &str) -> Self {
-        Self {
-            message: message.to_string(),
-        }
-    }
-}
-
-impl Display for CompilerError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", &self.message)
-    }
-}
-
-impl Error for CompilerError {}
-
-impl From<CompilerError> for std::io::Error {
-    fn from(e: CompilerError) -> Self {
+impl From<ElasticError> for std::io::Error {
+    fn from(e: ElasticError) -> Self {
         Self::new(std::io::ErrorKind::InvalidInput, e.message)
     }
 }

src/lexer.rs

 use lazy_static::lazy_static;
 use regex::Regex;
 
-use crate::error::LexerError;
+use crate::error::ElasticError;
 use crate::token::{Token, TokenType};
 
 #[derive(Debug)]
     ];
 }
 
-pub fn scan(input: &str) -> Result<Vec<Token>, LexerError> {
+pub fn scan(input: &str) -> Result<Vec<Token>, ElasticError> {
     let mut tokens: Vec<Token> = vec![];
     let mut position = 0;
 
         }
 
         if !matched {
-            return Err(LexerError::new("Unrecognized sequence"));
+            return Err(ElasticError::new("Unrecognized sequence"));
         }
     }
 

src/lib.rs

 pub mod lexer;
 pub mod parser;
 pub mod token;
+
+use compiler::Query;
+use error::ElasticError;
+
+pub fn compile(input: &str) -> Result<Query, ElasticError> {
+    let tokens = lexer::scan(&input)?;
+    let select = parser::parse(tokens)?;
+    compiler::compile(select)
+}

src/main.rs

-use elastic::parser;
-use elastic::{compiler::compile, lexer};
-
-use std::env;
-
-fn main() -> std::io::Result<()> {
-    let args: Vec<String> = env::args().into_iter().skip(1).collect();
-    let input = args.join(" ");
-    let tokens = lexer::scan(&input)?;
-    let select = parser::parse(tokens)?;
-    let result = compile(select)?;
-
-    println!("{}", result);
-
-    Ok(())
-}

src/parser.rs

 use std::{iter::Peekable, slice::Iter};
 
-use crate::error::ParserError;
+use crate::error::ElasticError;
 use crate::token::{Token, TokenType};
 
 #[derive(Debug, PartialEq)]
     }
 }
 
-pub fn parse(tokens: Vec<Token>) -> Result<Select, ParserError> {
+pub fn parse(tokens: Vec<Token>) -> Result<Select, ElasticError> {
     parse_select_expression(&mut tokens.iter().peekable())
 }
 
-fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select, ParserError> {
+fn parse_select_expression(tokens: &mut Peekable<Iter<Token>>) -> Result<Select, ElasticError> {
     eat(tokens, TokenType::Select)?;
     let fields = parse_fields(tokens)?;
     eat(tokens, TokenType::From)?;
     Ok(Select { fields, source })
 }
 
-fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, ParserError> {
+fn parse_fields(tokens: &mut Peekable<Iter<Token>>) -> Result<Vec<Field>, ElasticError> {
     if current_token_is(tokens, TokenType::Star) {
         eat(tokens, TokenType::Star).and_then(|_| Ok(vec![Field::Star]))
     } else {
 fn eat<'a>(
     tokens: &'a mut Peekable<Iter<Token>>,
     token_type: TokenType,
-) -> Result<&'a Token, ParserError> {
+) -> Result<&'a Token, ElasticError> {
     match tokens.next() {
         Some(token) => {
             if token.token_type == token_type {
                 Ok(token)
             } else {
-                Err(ParserError::new(&format!(
+                Err(ElasticError::new(&format!(
                     "Expected {} but got {}",
                     token_type, token.token_type
                 )))
             }
         }
-        None => Err(ParserError::new("Unexpected end of tokens")),
+        None => Err(ElasticError::new("Unexpected end of tokens")),
     }
 }
 
     use super::*;
     use crate::lexer::scan;
 
-    fn _parse(input: &str) -> Result<Select, ParserError> {
+    fn _parse(input: &str) -> Result<Select, ElasticError> {
         let tokens = scan(input).unwrap();
         parse(tokens)
     }