Merge pull request #7 from KPMGE/implement-builtin-functions

Implement builtin functions

Cargo.toml

@@ -5,3 +5,4 @@ edition = "2021"
 
 [dependencies]
 gflags = "0.3.12"
+lazy_static = "1.4.0"

src/builtin.rs

@@ -0,0 +1,21 @@
+use crate::evaluator::Object;
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+pub type BuiltinFn = fn(Vec<Object>) -> Object;
+
+lazy_static! {
+    pub static ref BUILTIN_FUNCTIONS: HashMap<&'static str, BuiltinFn> =
+        HashMap::from([("len", len as BuiltinFn)]);
+}
+
+fn len(args: Vec<Object>) -> Object {
+    let first_obj = args
+        .first()
+        .expect("len function must be provided a string argument!");
+
+    match first_obj {
+        Object::String(str) => Object::Integer(str.len() as i32),
+        _ => panic!("len function must be provided a string argument!"),
+    }
+}

src/evaluator.rs

@@ -2,6 +2,8 @@ use crate::ast::{AstNode, BlockStatement, Expression, Statement};
 use crate::token::Token;
 use std::collections::HashMap;
 
+use crate::builtin::{BuiltinFn, BUILTIN_FUNCTIONS};
+
 #[derive(Default)]
 pub struct Evaluator {
     context: HashMap<String, Object>,
@@ -13,12 +15,13 @@ pub enum Object {
     Boolean(bool),
     String(String),
     Return(Box<Object>),
+    Builtin(BuiltinFn),
+    Null,
     Function {
         parameters: Vec<Token>,
         body: BlockStatement,
         scope: HashMap<String, Object>,
     },
-    Null,
 }
 
 impl Evaluator {
@@ -72,11 +75,7 @@ impl Evaluator {
 
                 Object::Null
             }
-            Expression::Identifier(let_name) => self
-                .context
-                .get(&let_name)
-                .expect("ERROR: Could not find identifer")
-                .clone(),
+            Expression::Identifier(name) => self.eval_identifier(name),
             Expression::FunctionExpression {
                 parameters, body, ..
             } => Object::Function {
@@ -92,6 +91,10 @@ impl Evaluator {
                 let function = self.eval(AstNode::Expression(*function));
 
                 match function {
+                    Object::Builtin(builtin_fn) => {
+                        let args = self.eval_expressions(arguments);
+                        builtin_fn(args)
+                    }
                     Object::Function {
                         parameters,
                         body,
@@ -103,6 +106,17 @@ impl Evaluator {
         }
     }
 
+    fn eval_identifier(&mut self, name: String) -> Object {
+        if let Some(function) = BUILTIN_FUNCTIONS.get(name.as_str()) {
+            return Object::Builtin(*function);
+        }
+
+        self.context
+            .get(&name)
+            .expect("ERROR: Could not find identifer")
+            .clone()
+    }
+
     fn eval_function_call(
         &mut self,
         parameters: Vec<Token>,
@@ -238,6 +252,7 @@ impl Object {
             Object::String(value) => value.to_string(),
             Object::Return(value) => value.inspect(),
             Object::Function { .. } => "function".to_string(),
+            Object::Builtin(..) => "null".to_string(),
             Object::Null => "null".to_string(),
         }
     }

src/lexer.rs

@@ -115,8 +115,6 @@ impl Lexer {
             self.read_char();
         }
 
-        self.read_char();
-
         str
     }
 

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod ast;
+mod builtin;
 pub mod evaluator;
 pub mod lexer;
 pub mod parser;

tests/evaluator.rs

@@ -150,3 +150,22 @@ fn given_a_string_expression_it_should_evaluate_correctly() {
 
     assert_eq!(evaluated_obj, expected_obj);
 }
+
+#[test]
+fn given_a_string_expression_when_calling_len_it_should_evaluate_correctly() {
+    let code = "len(\"kevin\")";
+    let expected_obj = Object::Integer(5);
+
+    let lexer = Lexer::new(code.to_string());
+    let mut parser = Parser::new(lexer);
+    let parsed_program = parser.parse_program();
+    let node = match parsed_program {
+        AstNode::Program { statements } => statements.first().unwrap().clone(),
+        _ => panic!("Unexpected AstNode!"),
+    };
+
+    let mut evaluator = Evaluator::new();
+    let evaluated_obj = evaluator.eval(node);
+
+    assert_eq!(evaluated_obj, expected_obj);
+}