Mass commit; changes unfortunately not made under source control

Author: Tko1

Cargo.toml

@@ -7,4 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-dyn-clone = "*"
+dyn-clone = "*"
+pest = "*"
+pest_derive = "*"
+nom = "*"
+text_io = "*"

src/environment.rs

@@ -0,0 +1,101 @@
+use crate::value::{Value,ToValue};
+use crate::namespace::{Namespace,Namespaces};
+use crate::Symbol;
+use crate::rust_core;
+use crate::rust_core::{AddFn,StrFn};
+
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::cell::RefCell;
+
+
+// @TODO lookup naming convention
+/// Inner value of our environment
+/// See Environment for overall purpose 
+#[derive(Debug,Clone)]
+pub struct EnvironmentVal {
+    curr_ns : Namespace,
+    namespaces : Namespaces 
+}
+impl EnvironmentVal {
+    /// Default main environment 
+    fn new_main_val() -> EnvironmentVal {
+	EnvironmentVal {
+	    curr_ns: Namespace::new(Symbol::intern("user"),
+				    RefCell::new(HashMap::new())),
+	    namespaces: Namespaces(RefCell::new(HashMap::new()))
+	}	
+    }
+}
+/// Our environment keeps track of the meaning of things 'right here', relative to where
+/// something is at (meaning, a form inside of a let might have a different meaning for
+/// the symbol x than a form outside of it, with a let introducing an additional local environment
+///
+/// Stores our namespaces and our current namespace, which themselves personally store our symbols
+/// mapped to values 
+#[derive(Debug,Clone)]
+pub enum Environment {
+    MainEnvironment(EnvironmentVal),
+    /// Points to parent environment
+    /// Introduced by Closures, and by let 
+    LocalEnvironment(Rc<Environment>,RefCell<HashMap<Symbol,Rc<Value>>>) 
+}
+use Environment::*;
+impl Environment {
+    pub fn new_main_environment() -> Environment {
+	MainEnvironment(EnvironmentVal::new_main_val()) 	
+    }
+    pub fn new_local_environment(outer_environment: Rc<Environment>) -> Environment {
+	LocalEnvironment(outer_environment,RefCell::new(HashMap::new()))
+    }
+    pub fn insert(&self,sym: Symbol,val: Rc<Value>)
+    {
+	match self {
+	    MainEnvironment(EnvironmentVal {curr_ns,..}) => {
+		curr_ns.insert(sym,val);
+	    },
+	    LocalEnvironment(_,mappings) => {
+		mappings.borrow_mut().insert(sym,val);
+	    }
+	}
+    }
+    pub fn get(&self, sym: &Symbol) -> Rc<Value> 
+    {
+	match self {
+	    MainEnvironment(EnvironmentVal {curr_ns,..}) => curr_ns.get(sym),
+	    
+	    LocalEnvironment(parent_env,mappings) => {
+		match mappings.borrow().get(sym) {
+		    Some(val) => Rc::clone(val),
+		    None => parent_env.get(sym) 
+		}
+	    }
+	}
+    }
+    pub fn clojure_core_environment() -> Rc<Environment> {
+	// Register our macros / functions ahead of time
+	let add_fn = rust_core::AddFn{};
+	let str_fn = rust_core::StrFn{};
+	// Hardcoded macros
+	let let_macro = Value::LetMacro{};
+	let quote_macro = Value::QuoteMacro{};
+	let def_macro = Value::DefMacro{};
+	let fn_macro = Value::FnMacro{};
+	let defmacro_macro = Value::DefmacroMacro{};
+	
+	let mut environment = Rc::new(Environment::new_main_environment());
+	
+	let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
+
+	environment.insert(Symbol::intern("+"),add_fn.to_rc_value());
+	environment.insert(Symbol::intern("let"),let_macro.to_rc_value());
+	environment.insert(Symbol::intern("str"),str_fn.to_rc_value());
+	environment.insert(Symbol::intern("quote"),quote_macro.to_rc_value());
+	environment.insert(Symbol::intern("def"),def_macro.to_rc_value());
+	environment.insert(Symbol::intern("fn"),fn_macro.to_rc_value());
+	environment.insert(Symbol::intern("defmacro"),defmacro_macro.to_rc_value());
+	environment.insert(Symbol::intern("eval"),eval_fn.to_rc_value());
+
+	environment
+    }
+}

src/ifn.rs

@@ -0,0 +1,39 @@
+//! Trait for function-like things 
+//!
+//! An IFn is something that can be invoked on arguments, like:
+//! a function,
+//!    (+ 1 2)
+//! a macro
+//!    (-> 1 (+ 5) (* 10)))
+//! a keyword
+//!    (:name {:name "Blah" :age 20})
+//! a map
+//!    ({:name "Blah" :age 20} :name)
+//! As well as a few more types. 
+use crate::value::Value;
+use dyn_clone::DynClone;
+use std::fmt::Debug;
+
+//
+// Based on: clojure.lang.IFn 
+//
+// Naming this is a bit difficult, as 
+// 1. Rust already has a Fn trait 
+// 2. Naming this IFn or not naming this IFn introduces consistency and inconsistency;
+//
+//    Keeping 'IFn' introduces consistency because not just does the
+//    original ClojureJVM have an IFn in the Java underneath, but
+//    Clojure itself carries on this idea even as we leave the JVM (as,
+//    for instance, ifn is implemented in Clojurescript via)
+//
+//    Inconsistency, because Rust surely does not name traits 'ITrait'. 
+//
+// I've regardless kept it as IFn, and you might say IFn here is
+// referring to the Clojure idea of an IFn, implemented in Rust with a
+// trait, rather than saying 'this is an interface called Fn'
+//
+ 
+pub trait IFn : Debug + DynClone {
+    fn invoke(&self,args: Vec<&Value>) -> Value;
+}
+dyn_clone::clone_trait_object!(IFn);

src/lambda.rs

@@ -0,0 +1,58 @@
+use crate::environment::Environment;
+use crate::ifn::IFn;
+use crate::value::{Value,ToValue,Evaluable};
+use crate::persistent_list::ToPersistentList;
+use std::rc::Rc;
+use crate::symbol::Symbol;
+
+#[derive(Debug,Clone)]
+pub struct Fn {
+    pub body: Rc<Value>,
+    // Closed over variables 
+    pub enclosing_environment: Rc<Environment>,
+    pub arg_syms: Vec<Symbol>
+}
+impl ToValue for Fn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for Fn {
+    fn invoke(&self,args: Vec<&Value>) -> Value {
+	let local_environment = Rc::new(Environment::new_local_environment(Rc::clone(&self.enclosing_environment)));
+
+	let argc = self.arg_syms.len();
+	
+	let mut var_args = false;
+	if(argc >= 2) { 
+	    if let Some(sym) = self.arg_syms.get(argc - 2)
+	    {
+		if sym.to_string() == "&" { 
+		    var_args = true;
+		    let last_sym = self.arg_syms.get(argc - 1).unwrap();
+		    local_environment.insert(last_sym.clone(),Rc::new(Value::Nil));
+		}
+	    }
+	}
+	
+	if !var_args && args.len() != argc {
+	    return Value::Condition(format!("Wrong number of arguments given to function (Given: {}, Expected: {})",args.len(),argc));
+	}
+
+	for (i,arg) in args.iter().enumerate() {
+	    let curr_sym = self.arg_syms.get(i).unwrap();
+	    // We can bind the rest of the arguments, then, to the next variable and blow this popsicle stand
+	    if curr_sym.to_string() == "&" {
+		if (!var_args) {
+		    return Value::Condition(String::from("Invalid function argument '&' in non-variable-argument function definition"));
+		}
+		let last_sym = self.arg_syms.get(i + 1).unwrap();
+		let rest_args = args.get(i..).unwrap().to_vec().into_list().to_rc_value();
+		local_environment.insert(last_sym.clone(),rest_args);
+		break;
+	    }
+	    local_environment.insert(curr_sym.clone(),arg.to_rc_value());
+	}
+	self.body.eval(local_environment)
+    }
+}

src/main.rs

@@ -1,17 +1,90 @@
+#[macro_use]
+extern crate nom;
+
 mod rust_core;
 mod symbol;
 mod type_tag;
 mod value;
-
-use rust_core::AddFn;
-use crate::value::{IFn,ToValue};
+mod environment;
+mod namespace;
+mod ifn;
+mod lambda;
+mod reader;
+mod persistent_list;
+mod persistent_vector;
+
+use environment::Environment;
+
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::io::{self,Read};
+use std::str::FromStr;
+use std::io::BufRead;
+use std::fs::File;
+
+use rust_core::{AddFn,StrFn};
+use symbol::Symbol;
+use crate::value::{ToValue,Evaluable};
+use crate::persistent_list::{PersistentList,ToPersistentList};
+use crate::persistent_vector::{PersistentVector,ToPersistentVector};
+use crate::value::Value;
 
 fn main()
 {
-    let add_fn = AddFn{};
-    let result = add_fn.invoke(&[&5_i32.to_value(),&6_i32.to_value(),&10_i32.to_value()]);
-
-    println!("{:?}",result);
+    // Register our macros / functions ahead of time
+    let add_fn = rust_core::AddFn{};
+    let str_fn = rust_core::StrFn{};
+    let do_fn = rust_core::DoFn{};
+    let nth_fn = rust_core::NthFn{};
+    let do_macro = rust_core::DoMacro{};
+    let concat_fn = rust_core::ConcatFn{};
+    // Hardcoded macros
+    let let_macro = Value::LetMacro{};
+    let quote_macro = Value::QuoteMacro{};
+    let def_macro = Value::DefMacro{};
+    let fn_macro = Value::FnMacro{};
+    let defmacro_macro = Value::DefmacroMacro{};
+    
+    let environment = Rc::new(Environment::new_main_environment());
+    
+    let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
+    
+    environment.insert(Symbol::intern("+"),add_fn.to_rc_value());
+    environment.insert(Symbol::intern("let"),let_macro.to_rc_value());
+    environment.insert(Symbol::intern("str"),str_fn.to_rc_value());
+    environment.insert(Symbol::intern("quote"),quote_macro.to_rc_value());
+    environment.insert(Symbol::intern("do-fn*"),do_fn.to_rc_value());
+    environment.insert(Symbol::intern("do"),do_macro.to_rc_value());
+    environment.insert(Symbol::intern("def"),def_macro.to_rc_value());
+    environment.insert(Symbol::intern("fn"),fn_macro.to_rc_value());
+    environment.insert(Symbol::intern("defmacro"),defmacro_macro.to_rc_value());
+    environment.insert(Symbol::intern("eval"),eval_fn.to_rc_value());
+    environment.insert(Symbol::intern("nth"),nth_fn.to_rc_value());
+    environment.insert(Symbol::intern("concat"),concat_fn.to_rc_value());
+    //
+    // Start repl 
+    //
+    let stdin = io::stdin();
+    print!("user=> ");
+    for line in stdin.lock().lines() {
+	let line = line.unwrap();
+	let mut remaining_input = line.as_bytes();
+	loop {
+	    let next_read_parse = reader::try_read(remaining_input);
+	    match next_read_parse {
+		Ok((_remaining_input,value)) => {
+		    print!("{} ",value.eval(Rc::clone(&environment)).to_string_explicit());
+		    remaining_input = _remaining_input;
+		},
+		_ => {
+		    break;
+		}
+	    }
+	}
+	println!();
+	print!("user=> ");
+    }
+    
 }
 
 

src/namespace.rs

@@ -1,10 +1,32 @@
+use crate::value::{Value};
+use crate::value::ToValue;
+use crate::Symbol;
+use crate::rust_core::{AddFn,StrFn};
 use std::collections::HashMap;
-use symbol::Symbol;
-use value::Value;
+use std::rc::Rc;
+use std::cell::RefCell;
 
+#[derive(Debug,Clone)]
 pub struct Namespace {
-    name: Symbol,
-    mappings: HashMap<Symbol,Value>
+    pub name: Symbol,
+    mappings: RefCell<HashMap<Symbol,Rc<Value>>>
 }
+impl Namespace {
+    pub fn new(name: Symbol, mappings: RefCell<HashMap<Symbol,Rc<Value>>>) -> Namespace {
+	Namespace { name,mappings } 
+    }
+    pub fn insert(&self,sym: Symbol, val: Rc<Value>)
+    {
+	self.mappings.borrow_mut().insert(sym,val);
+    }
+    pub fn get(&self, sym: &Symbol) -> Rc<Value>
+    {
+	match self.mappings.borrow_mut().get(sym) {
+	    Some(val) => Rc::clone(val),
+	    None => Rc::new(Value::Condition(format!("Undefined symbol {}",sym.name)))
+	}
+    }
+}
+#[derive(Debug,Clone)]
+pub struct Namespaces(pub RefCell<HashMap<Symbol,Namespace>>);
 
-struct Namespaces(HashMap<Symbol,Namespace>);