From 566339318db89bcc434c248f86375708239d235d Mon Sep 17 00:00:00 2001
From: Dominick Allen <dominick.allen1989@gmail.com>
Date: Sat, 27 Jun 2020 20:08:45 -0500
Subject: Fixed tokenize.

---
 src/lib/mod.rs      |  2 +-
 src/lib/tokenize.rs | 22 ++++++++++------------
 src/main.rs         |  2 +-
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/lib/mod.rs b/src/lib/mod.rs
index bf4584c..e2bb978 100644
--- a/src/lib/mod.rs
+++ b/src/lib/mod.rs
@@ -1,5 +1,5 @@
 pub mod environment;
 pub mod eval;
-pub mod parse;
+pub mod tokenize;
 pub mod sexpr;
 pub mod types;
diff --git a/src/lib/tokenize.rs b/src/lib/tokenize.rs
index 384b04f..0a50036 100644
--- a/src/lib/tokenize.rs
+++ b/src/lib/tokenize.rs
@@ -1,7 +1,7 @@
 use super::types::Type;
 use super::types::Number;
 use super::types::Op;
-use super::types::SEXP;
+use super::sexpr::SExpr;
 
 pub type MaybeToken = (Option<Result<Token, String>>, usize);
 
@@ -134,7 +134,7 @@ fn analyze2(expr: &str) -> MaybeToken {
         (Some(Ok(Token::Value(Type::Bool(true)))), 4)
     } else if word == "false" {
         (Some(Ok(Token::Value(Type::Bool(false)))), 5)
-    } else if let Ok(op) = word.tokenize::<Op>() {
+    } else if let Ok(op) = word.parse::<Op>() {
         (Some(Ok(Token::Value(Type::Operator(op)))), word.len())
     } else if c.is_alphabetic() {
         (Some(Ok(Token::Value(Type::Symbol(word.to_string())))), word.len())
@@ -170,7 +170,7 @@ pub fn is_paren(expr: &str) -> MaybeToken {
 
 pub fn is_op(expr: &str) -> MaybeToken {
     let word = make_word(expr);
-    match word.tokenize::<Op>() {
+    match word.parse::<Op>() {
         Ok(op) => (Some(Ok(Token::Value(Type::Operator(op)))), word.len()),
         _      => (None, 0)
     }
@@ -235,22 +235,20 @@ pub fn is_number(expr: &str) -> MaybeToken {
 }
 
 pub fn is_int(word: &str) -> MaybeToken {
-    //let word = make_word(expr);
-    match word.tokenize::<isize>() {
+    match word.parse::<isize>() {
         Ok(x) => (Some(Ok(Token::Value(Type::Number(Number::Int(x))))), word.len()),
         _ => (None, 0)
     }
 }
 
 pub fn is_float(word: &str) -> MaybeToken {
-    //let word = make_word(expr);
-    match word.tokenize::<f32>() {
+    match word.parse::<f32>() {
         Ok(x) => (Some(Ok(Token::Value(Type::Number(Number::Float(x))))), word.len()),
         _ => (None, 0)
     }
 }
 
-pub fn tokenize(expr: &str) -> Result<SEXP, String> {
+pub fn tokenize(expr: &str) -> Result<SExpr, String> {
     let mut tokenstream = TokenStream::default(expr);
     match tokenstream.peek() {
         Some(Ok(Token::LParen)) => {
@@ -258,13 +256,13 @@ pub fn tokenize(expr: &str) -> Result<SEXP, String> {
             descend(&mut tokenstream)
         },
         Some(Ok(Token::RParen)) => Err("Malformed expression".to_string()),
-        Some(Ok(Token::Value(x))) => Ok(SEXP::Atom(x)),
+        Some(Ok(Token::Value(x))) => Ok(SExpr::Atom(x)),
         Some(Err(f)) => Err(f),
         None => Err("Empty expression".to_string())
     }
 }
 
-pub fn descend(tokenstream: &mut TokenStream) -> Result<SEXP, String> {
+pub fn descend(tokenstream: &mut TokenStream) -> Result<SExpr, String> {
     let mut sexp = Vec::new();
     loop {
         let token = match tokenstream.next() {
@@ -286,11 +284,11 @@ pub fn descend(tokenstream: &mut TokenStream) -> Result<SEXP, String> {
                 break;
             },
             Token::Value(atom) => {
-                sexp.push(SEXP::Atom(atom));
+                sexp.push(SExpr::Atom(atom));
                 continue;
             }
         }
     }
 
-    Ok(SEXP::Sexpr(sexp))
+    Ok(SExpr::Sexpr(sexp))
 }
diff --git a/src/main.rs b/src/main.rs
index 49c916a..c2f9881 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -38,7 +38,7 @@ fn means_exit(input: &str) -> bool {
 }
 
 fn eval(env: &mut Environment, input: &str) -> String {
-    let sexp = match lib::parse::parse(input) {
+    let sexp = match lib::tokenize::tokenize(input) {
         Ok(x) => x,
         Err(f) => return f
     };
-- 
cgit v1.2.3