Begin work on standard library

Unfortunately, it seems like I am walled.

Manishearth/rust-gc#50

I thought the garbage collection story in Rust was more mature than it
actually is, and that I could ride the coattails of those who know how
the hell garbage collection actually works. Either I switch gears and
learn how to situate myself in garbage, or I call this project a dead
end because I'm running out of steam. :)

Author: SkylerLipthay

src/bin/eval.rs

@@ -1,14 +1,17 @@
 extern crate bean;
 
 use bean::context::Context;
+use bean::std_scope;
 use std::io::{self, Read};
 use std::time::SystemTime;
 
 fn main() {
     let mut buffer = String::new();
     io::stdin().read_to_string(&mut buffer).unwrap();
     let before = SystemTime::now();
-    let result = Context::new().eval(&buffer);
+    let mut context = Context::new();
+    context.push_scope(std_scope::scope());
+    let result = context.eval(&buffer);
     let elapsed = SystemTime::now().duration_since(before).unwrap();
     println!("Total execution time: {:?}", elapsed);
     println!("{:#?}", result);

src/context.rs

@@ -122,6 +122,10 @@ impl Context {
         Context { scopes: Vec::new() }
     }
 
+    pub fn push_scope(&mut self, scope: Object) {
+        self.scopes.push(scope);
+    }
+
     pub fn eval(&mut self, source: &str) -> Result<Value, Error> {
         Ok(self.eval_block(&Parser::parse_script(source)?)?)
     }
@@ -504,6 +508,9 @@ impl Context {
         // function was not defined in the current script. May have to accept a filename parameter
         // to disambiguate, or come up with another solution. Perhaps if no filename is supplied,
         // the error is "localized" to the caller's location (i.e. the line/column point to `pos`).
+        //
+        // Moreover, errors produced by native Rust functions are never tagged with a line/column.
+        // Can this be improved?
         let func = self.eval_expr(func)?;
         if let Value::Function(ref func) = func {
             self.eval_call_inner_exprs(func, args)

src/lib.rs

@@ -8,4 +8,5 @@ pub mod iter;
 pub mod lexer;
 pub mod parser;
 pub mod position;
+pub mod std_scope;
 pub mod value;

src/std_scope.rs

@@ -0,0 +1,50 @@
+use crate::value::{Object, Value};
+
+pub fn scope() -> Object {
+    let scope = Object::new();
+    let std = Object::new();
+
+    std.set("len", Value::rust_function(|_ctx, args| {
+        match args.get(0) {
+            Some(Value::Array(arr)) => Ok(Value::Number(arr.len() as f64)),
+            Some(Value::Object(obj)) => Ok(Value::Number(obj.len() as f64)),
+            _ => Err(Value::string("invalid argument")),
+        }
+    }));
+
+    std.set("iter", Value::rust_function(|_ctx, args| {
+        match args.get(0) {
+            Some(Value::Array(arr)) => {
+                let iter = Object::new();
+                let iter_clone = iter.clone();
+                // TODO: Can `args` be destructured to prevent this clone?
+                let arr = arr.clone();
+
+                // TODO: Use internal object value for this:
+                iter.set("_index", Value::Number(0.0));
+
+                // TODO: Bad news, gamers. https://github.com/Manishearth/rust-gc/issues/50
+                iter.set("next", Value::rust_function(move |_ctx, _args| {
+                    let next = Object::new();
+                    let index = match iter_clone.get("_index") {
+                        Some(Value::Number(number)) => number as usize,
+                        _ => panic!("TODO: Use internal object value for this"),
+                    };
+                    if let Some(value) = arr.get(index) {
+                        iter_clone.set("_index", Value::Number((index + 1) as f64));
+                        next.set("value", value);
+                    } else {
+                        next.set("done", Value::Boolean(true));
+                    }
+                    Ok(Value::Object(next))
+                }));
+
+                Ok(Value::Object(iter))
+            },
+            _ => Err(Value::string("invalid argument")),
+        }
+    }));
+
+    scope.set("std", Value::Object(std));
+    scope
+}

src/value.rs

@@ -179,6 +179,10 @@ impl Array {
     pub fn get(&self, index: usize) -> Option<Value> {
         self.0.borrow().get(index).cloned()
     }
+
+    pub fn len(&self) -> usize {
+        self.0.borrow().len()
+    }
 }
 
 #[derive(Clone, Debug, Trace, Finalize)]
@@ -201,4 +205,8 @@ impl Object {
     pub fn contains(&self, key: &str) -> bool {
         self.0.borrow().contains_key(key)
     }
+
+    pub fn len(&self) -> usize {
+        self.0.borrow().len()
+    }
 }