Got function calling working

Author: cjrh

Cargo.toml

@@ -5,3 +5,7 @@ edition = "2021"
 
 [dev-dependencies]
 rstest = "0.23.0"
+
+[dependencies]
+log = "0.4.22"
+pretty_env_logger = "0.5.0"

src/lib.rs

@@ -1,7 +1,8 @@
 // lib.rs
-use std::io::Write;
+use std::io::{self, Write};
 use std::collections::HashMap;
 use std::error::Error;
+use log::*;
 
 #[derive(Debug, Clone)]
 pub enum Token {
@@ -20,6 +21,7 @@ pub enum Token {
     Divide,
     LParen,
     RParen,
+    Function(String), // Represents a function invocation like :add
     Open,
     ReadLines,
     Clear,
@@ -30,43 +32,50 @@ impl std::str::FromStr for Token {
     type Err = &'static str;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "." => Ok(Token::Display),
-            "+" => Ok(Token::Plus),
-            "-" => Ok(Token::Minus),
-            "*" => Ok(Token::Multiply),
-            "/" => Ok(Token::Divide),
-            "(" => Ok(Token::LParen),
-            ")" => Ok(Token::RParen),
-
-            "open" => Ok(Token::Open),
-            "readlines" => Ok(Token::ReadLines),
-            "clear" => Ok(Token::Clear),
-            "listdir" => Ok(Token::ListDir),
-
-            "arrnum" => Ok(Token::MakeArrayNumberI32),
-            "arrtxt" => Ok(Token::MakeArrayText),
-            "join" => Ok(Token::Join),
-            _ => {
-                if let Ok(number) = s.parse::<i32>() {
-                    Ok(Token::NumberI32(number))
-                } else {
-                    Ok(Token::Text(s.to_string()))
-                }
+        debug!("Parsing token: {}", s);
+        if s.starts_with(':') {
+            if s.len() == 1 {
+                Err("Invalid function name")
+            } else {
+                Ok(Token::Function(s[1..].to_string()))
             }
+        } else if s == "." {
+            Ok(Token::Display)
+        } else if s == "+" {
+            Ok(Token::Plus)
+        } else if s == "-" {
+            Ok(Token::Minus)
+        } else if s == "*" {
+            Ok(Token::Multiply)
+        } else if s == "/" {
+            Ok(Token::Divide)
+        } else if s == "(" {
+            Ok(Token::LParen)
+        } else if s == ")" {
+            Ok(Token::RParen)
+        } else if s == "clear" {
+            Ok(Token::Clear)
+        } else if s == "listdir" {
+            Ok(Token::ListDir)
+        } else if let Ok(number) = s.parse::<i32>() {
+            Ok(Token::NumberI32(number))
+        } else {
+            Ok(Token::Text(s.to_string()))
         }
     }
 }
 
+#[derive(Default)]
 pub struct Stack {
     items: Vec<Token>,
+    pub functions: HashMap<String, Vec<Token>>, // Stores function definitions
+    literal_mode: bool,
 }
 
+
 impl Stack {
     pub fn new() -> Stack {
-        Stack {
-            items: vec![],
-        }
+        Stack::default()
     }
 
     pub fn clear(&mut self) {
@@ -79,15 +88,29 @@ impl Stack {
 
     pub fn display(&self) {
         println!("{}", self.repr());
+        println!("Functions: {:?}", self.functions);
     }
 
     pub fn push_str(&mut self, item: &str) -> Result<(), Box<dyn Error>> {
-        match item.parse::<Token>() {
-            Ok(token) => {
-                self.push(token)?;
-            },
-            Err(_) => {
-                self.push(Token::Text(item.to_string()))?;
+        if item.starts_with('`') && item.len() > 1 {
+            // Single-token literal
+            self.push(Token::Text(item[1..].to_string()))?;
+        } else if item == "`" {
+            // Enter literal mode
+            self.literal_mode = true;
+        } else if item == "~" && self.literal_mode {
+            // Exit literal mode
+            self.literal_mode = false;
+        } else if self.literal_mode {
+            // Add as literal in literal mode
+            self.push(Token::Text(item.to_string()))?;
+        } else {
+            match item {
+                ":make-fn" => self.make_function()?,
+                _ => match item.parse::<Token>() {
+                    Ok(token) => self.push(token)?,
+                    Err(_) => self.push(Token::Text(item.to_string()))?,
+                },
             }
         }
         Ok(())
@@ -104,6 +127,7 @@ impl Stack {
             Token::Minus => self.subtract()?,
             Token::Multiply => self.multiply()?,
             Token::Divide => self.divide()?,
+            Token::Function(name) => self.call_function(&name)?,
             Token::LParen => todo!(),
             Token::RParen => todo!(),
             Token::Open => todo!(),
@@ -118,6 +142,45 @@ impl Stack {
         Ok(())
     }
 
+    fn call_function(&mut self, name: &str) -> Result<(), Box<dyn Error>> {
+        debug!("Calling function: {}", name);
+        if let Some(definition) = self.functions.get(name) {
+            debug!("Function definition: {:?}", definition);
+            for token in definition.clone() {
+                let s = match token {
+                    Token::Text(value) => value, // End marker
+                    _ => return Err("Expected a text value".into()),
+                };
+                let operation = s.parse::<Token>()?;
+                self.push(operation)?;
+            }
+            Ok(())
+        } else {
+            Err(format!("Undefined function: {}", name).into())
+        }
+    }
+
+    fn make_function(&mut self) -> Result<(), Box<dyn Error>> {
+        let mut tokens = vec![];
+
+        // Collect tokens until the stack contains the function name
+        while let Some(token) = self.pop() {
+            match token {
+                Token::Text(value) if value == "~" => break, // End marker
+                Token::Text(value) => tokens.push(Token::Text(value)),
+                _ => return Err("Expected a text value".into()),
+            }
+        }
+        debug!("Function tokens: {:?}", tokens);
+
+        if let Some(Token::Text(name)) = tokens.pop() {
+            self.functions.insert(name, tokens);
+            Ok(())
+        } else {
+            Err("Expected a function name".into())
+        }
+    }
+
     fn join(&mut self) -> Result<(), Box<dyn Error>> {
         if let Some(Token::ArrayText(items)) = self.pop() {
             let total = items.join("");
@@ -245,5 +308,4 @@ impl Stack {
         output.push(self.repr());
         Ok(output)
     }
-
 }

tests/test_basic.rs

@@ -1,7 +1,14 @@
 /// Tests for the Plenty interpreter. We will load in scripts of Plenty and execute them,
 /// checking the output against the expected output.
+use log::*;
 use plenty::Stack;
-use rstest::rstest;
+use pretty_env_logger;
+use rstest::{rstest, fixture};
+
+#[fixture]
+fn setup_logger() {
+    let _ = pretty_env_logger::try_init();
+}
 
 #[rstest]
 #[case("1 2 + .", vec!["[NumberI32(3)]"])]
@@ -10,8 +17,32 @@ use rstest::rstest;
 #[case("10 2 - .", vec!["[NumberI32(8)]"])]
 #[case("1 2 3 4 5 6 +", vec!["[NumberI32(1), NumberI32(2), NumberI32(3), NumberI32(4), NumberI32(11)]"])]
 #[case("1 2 +\n3 +", vec!["[NumberI32(6)]"])]
-fn test_programs(#[case] program: &str, #[case] expected_output: Vec<&str>) {
+fn test_programs(setup_logger: (), #[case] program: &str, #[case] expected_output: Vec<&str>) {
+    let mut stack = Stack::new();
+    let actual_output = stack.run_program(program).unwrap();
+    assert_eq!(actual_output, expected_output);
+}
+
+// Let's test function creation
+#[rstest]
+#[case("` add + ~ :make-fn", "{\"add\": [Text(\"+\")]}")]
+fn test_function_creation(setup_logger: (), #[case] program: &str, #[case] expected_output: &str) {
+    let mut stack = Stack::new();
+    let _actual_output = stack.run_program(program).unwrap();
+    debug!("{:?}", stack.functions);
+    let out = format!("{:?}", stack.functions);
+    assert_eq!(out, expected_output);
+}
+
+// Let's test function calling
+#[rstest]
+// Define a new function, and then call it
+#[case("` add + ~ :make-fn\n1 2 :add", vec!["[NumberI32(3)]"])]
+// Important: no difference between newline or space
+#[case("` add + ~ :make-fn 1 2 :add", vec!["[NumberI32(3)]"])]
+fn test_function_calling(setup_logger: (), #[case] program: &str, #[case] expected_output: Vec<&str>) {
     let mut stack = Stack::new();
     let actual_output = stack.run_program(program).unwrap();
+    debug!("after run program: {:?}", stack.repr());
     assert_eq!(actual_output, expected_output);
 }