Restructured project and split up into appropriate files

(commit larger than intended); "dyn Any" is now expressed with a large
'Value' enum, Expr type removedRestructured project and split up into
appropriate files; "dyn Any" is now expressed with a large 'Value'
enum, Expr type removed

Author: Tko1

clojureRS.org

@@ -0,0 +1,102 @@
+* Design Notes 
+** Dynamic Typing 
+   Let's say we have a function like the invoke function (check out
+   clojure.lang.IFn) for function-like types, which takes a variable
+   number of arguments whose types are not known at compile time.  In
+   Java, this looks like
+   
+   #+BEGIN_SRC java
+   public Object invoke(Object arg1,Object arg2 ...)  
+    #+END_SRC
+
+   In Rust, for now to my knowledge our two options for dynamic typing 
+   are to 
+
+   1. Use trait objects (combined with the Any trait specifically), something like 
+   #+BEGIN_SRC rust
+      fn invoke<'a>(arg1: &'a dyn Any, ..) -> &'a dyn Any 
+   #+END_SRC 
+
+      (But, considering that really we want to be often returning a
+      new value with invoke, and thus our 'reference', despite
+      starting in the function, should be existing beyond the function
+      itself, we'd more so probably need to return a proper pointer on
+      the heap, perhaps a Box<dyn Any>.  When I was experimenting with
+      this approach, I ended up using a Rc<dyn Any>, which fit better
+      with some other implementation details and was 'easier', but there 
+      was still a lot to explore there)
+   
+   or  
+
+   2. To have a wrapper ADT (enum) that knows all possible types ahead of time; ie, something like 
+      #+BEGIN_SRC rust 
+      fn invoke(arg1: &Value,..) -> Value  
+
+      enum Value { 
+        I32(i32),
+        Symbol(Symbol),
+        Keyword(Keyword), 
+        .. 
+      }
+      #+END_SRC
+
+   For now, I have moved forward with #2, as there appear to be some
+   major issues one runs into with #1,  although I am open to hearing 
+   from others wiser than I in Rust 
+*** TODO Document problem with #1  
+   
+** Exceptions 
+   How best represent exceptions? 
+*** Conditions 
+    First off, I'd like to play with having flat out Conditions, as
+    you have in something like Common Lisp, over Exceptions.  This
+    would be a difference from Clojure, so I'm not sure if this
+    sort of divergence would require me not call this Clojure (at the
+    same time, 'a full on Clojure that gets to live on its own, and be
+    all that it wants to be without inheriting the restrictions of the
+    JVM' is part of what I want to play with here).
+*** Implementation 
+    There's a few things to think about here, for now let's just have
+    erroneous situations flat out return a Condition type, and start
+    adding more behavior when we get back to this.
+
+** Keeping the codebase close 
+   Originally, at least ,the goal was to keep the Rust base as similar
+   to the Java / C# codebase as possible for consistency, but now I am
+   thinking the program may just as easily end up split up and
+   designed completely differently. 
+
+   Either way, each part in common will try to be as consistent with
+   the original Java version as possible -- and sometimes this will
+   involve not going quite with Rust conventions, as is the example of
+   the IFn trait, which for now is keeping the IFn name. See notes at 
+   top of  IFn for more info
+
+** Explore more the idea of a clean rust FFI / interop, in the usual spirit of Clojure 
+   I get the impression that runtime reflection in Rust would be difficult if not downright
+   impossible,  so for now I would like to look into producing our interop functions at compile time
+   (or rather, 'pre compile time'; parsing our rust files,  producing the appropriate ClojureRS rust code bridging
+   the two, and the compiling the entire project after)
+
+** Clojure map comments  
+   For now, I decided to add some meta data to some of the Rust-Clojure functions as an actual map in the comment
+   (ie, 
+#+BEGIN_SRC rust 
+/*
+{:clojure-fn "+"} 
+*/
+struct AddFn { 
+}
+#+END_SRC 
+  I am not 100% I have a conscious reasoning yet, but I often like
+  expressing data just as data, this is one of the draws of Clojure
+  for me as it is. The map here is explicit, it is human readable, but
+  also easily reflected read and manipulated by software. And it is
+  expressed with the same, to-the-point language you can use to
+  express any other information.
+
+  Anyways, for now I am only listing the Var this function should
+  correspond to, as all other information can be found on said Var,
+  although if I later realize it helps to have this information on
+  the Rust implementation of a function at a glance , I'm not against
+  adding it there, even if its repeat information

readme.org

@@ -0,0 +1,23 @@
+* ClojureRS 
+
+  Put simply, Clojure implemented atop Rust! My main goals here are 
+
+** Project Goals:
+  1. To create a version of Clojure that gets to exist independent of a particular platform  
+  2. To explore a Clojure that, being more indepdent, has
+     a. Proper tail call elimination 
+     b. Conditions / Restarts 
+     c. Any other feature it might not normally be able to indulge 
+  3. To, should the project progress,  begin looking more serious into advanced compilation techniques,
+     to create a serious Clojure implementation 
+
+     Check clojureRS.org (the file, not website) for more notes about
+     the design of the language, which should grow as the program
+     grows.
+
+** Personal Goals:
+  1. Work a bit closer to the metal, and do so with Rust, two pleaures of mine
+  2. Work more with compilation, another pleasure  
+  3. Give myself a functional lisp to script with -- but not
+     necessarily because of any issue with our other clojure-scripting
+     options

src/main.rs

@@ -1,63 +1,50 @@
-use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::hash::{Hash,Hasher};
-use dyn_clone::DynClone;
-
-#[derive(Hash,PartialEq,Eq,Copy,Clone)]
-struct Symbol {
-    name: &'static str
-}
+mod rust_core;
+mod symbol;
+mod type_tag;
+mod value;
 
-trait IFn: DynClone {
-    fn invoke(&self,args: &[&dyn Any]) -> Box<dyn Any>;
-}
-dyn_clone::clone_trait_object!(IFn);
+use rust_core::AddFn;
+use crate::value::{IFn,ToValue};
 
-#[derive(Clone)]
-struct AddFn {
-}
-impl IFn for AddFn {
-    fn invoke(&self,args: &[&dyn Any]) -> Box<dyn Any>
-    {
-	Box::new(args.into_iter().fold(0,|a,b|  {
-	    let _a = a as i64;
-	    if let Some(_b) = b.downcast_ref::<i64>() {
-		_a + *_b
-	    }
-	    else {
-		_a
-	    }
-	    
-	}))
-    }
-}
-use crate::Expr::*;
-#[derive(Clone)]
-enum Expr {
-    SymbolExpr(Symbol),
-    FnExpr(Box<dyn IFn>),
-    i32Expr(i32),
-    nilExpr 
-}
-impl Expr {
-    fn eval(&self,environment: &HashMap<Symbol,Expr>) -> Expr{
-	match self {
-	    SymbolExpr(sym) => match environment.get(&sym) {
-		Some(expr) => expr.clone(),
-		_ => nilExpr
-	    },
-	    _ => nilExpr 
-	}
-	    
-    }
-}
+fn main()
+{
+    let add_fn = AddFn{};
+    let result = add_fn.invoke(&[&5_i32.to_value(),&6_i32.to_value(),&10_i32.to_value()]);
 
-fn main() {
-    let add = AddFn{};
-    let answer = add.invoke(&[&(1 as i64) as &dyn Any ,&(2 as i64) as &dyn Any]);
-    let answer_as_num = answer.downcast_ref::<i64>();// as Box<i64>;
-    
-    println!("Start:");
-    println!("{:?}",answer_as_num);
-    println!("Edn:");
+    println!("{:?}",result);
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/namespace.rs

@@ -0,0 +1,10 @@
+use std::collections::HashMap;
+use symbol::Symbol;
+use value::Value;
+
+pub struct Namespace {
+    name: Symbol,
+    mappings: HashMap<Symbol,Value>
+}
+
+struct Namespaces(HashMap<Symbol,Namespace>);

src/rust_core.rs

@@ -0,0 +1,42 @@
+//use crate::ifn::IFn;
+use crate::value::Value;
+use crate::value::{IFn,ToValue};
+/*
+This module will hold the core functions and macros that Clojure will
+hook into; Functions / Macros like "+", "fn*", "let", "cond", etc
+
+This is still experimental, and we may instead undo this all and
+represent fn* and let and the like the same it is done in ClojureJVM,
+where I believe they are defined flat out in the Compiler class
+
+However, even in that case this may stick around to implement basic
+functions like "+" that usually rely on interop
+
+*/
+
+/*
+{:clojure-equivalent '+,
+ :arglists '([name doc-string? attr-map? [params*] body]
+                 [name doc-string? attr-map? ([params*] body)+ attr-map?]) 
+ */
+#[derive(Debug)]
+pub struct AddFn {
+    
+
+}
+impl IFn for AddFn {
+    fn invoke(&self,args: &[&Value]) -> Value {
+	args.into_iter().fold(0_i32.to_value(),|a,b|  {
+	    match a {
+		Value::I32(a_) => match b {
+		    Value::I32(b_) =>  Value::I32(a_ + b_),
+		    // @TODO insert actual value of b and type into error message 
+			_ =>  Value::Condition(String::from("Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: "))
+		}
+		// @TODO insert actual value of b and type into error message 
+		_ => Value::Condition(String::from("Type mismatch: Expecting: (i32 | i64 | f32 | f64), Found: "))
+		      
+	    }
+	})
+    }
+}

src/symbol.rs

@@ -0,0 +1,6 @@
+use std::hash::{Hash,Hasher};
+
+#[derive(Hash,PartialEq,Eq,Clone,Debug)]
+pub struct Symbol {
+    pub name: String
+}

src/type_tag.rs

@@ -0,0 +1,6 @@
+pub enum TypeTag {
+    I32,
+    Symbol,
+    IFn,
+    Condition
+}

src/value.rs

@@ -0,0 +1,49 @@
+use crate::symbol::Symbol;
+use crate::type_tag::TypeTag;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::fmt::Debug;
+pub trait IFn : Debug {
+    fn invoke(&self,args: &[&Value]) -> Value;
+}
+#[derive(Debug)]
+pub enum Value {
+    I32(i32),
+    Symbol(Symbol),
+    IFn(Rc<dyn IFn>),
+    Condition(String)
+}
+impl Value {
+    fn type_tag(&self) -> TypeTag
+    {
+	match self {
+	    Value::I32(_) => TypeTag::I32,
+	    Value::Symbol(_) => TypeTag::Symbol,
+	    Value::IFn(_) => TypeTag::IFn,
+	    Value::Condition(_) => TypeTag::Condition
+	}
+    }
+    fn eval(self : Rc<Value>, environment: &HashMap<Symbol,Rc<Value>>) -> Rc<Value> {
+	match &*self {
+	    Value::Symbol(symbol) => match environment.get(symbol) {
+		Some(val) => Rc::clone(val),
+		_ => Rc::new(Value::Condition(format!("Undefined symbol {}",symbol.name)))
+	    }
+	    // I32, Fn 
+	    _ => Rc::clone(&self),
+	}
+    }
+}
+
+pub trait ToValue {
+    fn to_value(&self) -> Value; 
+}
+
+impl ToValue for i32 {
+    fn to_value(&self) -> Value {
+	Value::I32(self.clone()) 
+    }
+}
+
+
+