Refactor standard libraries and add namespacing

compiler.js

       })
       continue
     }
-    let characters = /[a-zA-Z_]/
+    let characters = /[a-zA-Z_:]/
     if (characters.test(char)) {
       let name = ''
       while (characters.test(char)) {
   switch (node.type) {
     case 'Prog':
       let program = node.body.map(generator)
-      program.unshift('var _ = require("./stdlib.js")')
+      program.unshift('var _ = require("./lib/stdlib.js")(this)')
       return program.join('\n')
       break
     case 'Statement':
       break
     case 'FunctionCall':
       if (!node.callee.name.match('(def|if|repeat)')) {
-        return (generator(node.callee) + '(' + node.args.map(generator).join(', ') + ')')
+        if (node.callee.name.match('include')) {
+          // Include is a special function and we will write the generation ourselves
+          if (node.args.length > 1) {
+            console.error("Compiler Error: (include) may only take 1 argument!")
+            process.exit(1)
+          } else {
+            let lib = './lib/' + node.args[0].value + '.js'
+            return ('var _' + node.args[0].value + ' = require("' + lib + '")(this)')
+          }
+        } else {
+          return (generator(node.callee) + '(' + node.args.map(generator).join(', ') + ')')
+        }
       } else {
         return (generator(node.callee) + '(' + node.args.map((v, i) => {
           if (i === 0) {
             return generator(v) + ', '
           } else {
             if (i === 1) {
-              return 'function() {' + generator(v) + ';'
+              return 'function() { \n' + generator(v) + ';\n'
             } else {
-              return generator(v) + '; '
+              return generator(v) + ';\n'
             }
           }
         }).join('') + '})')
       return '}, function() {'
       break
     case 'FunctionName':
-      return '_.' + node.name
+      if (node.name.match("::")) {
+        let [namespace, func] = node.name.split("::")
+        return "_" + namespace + "." + func
+      } else {
+        return '_.' + node.name
+      }
       break
     case 'VariableReference':
       return '_.ref(\'' + node.value + '\')'

example.mc

 ; This is a test program
+(include str)
 (assign twelve 12) ; This assigns the variable twelve, to the number literal 12
 (assign myvar (add twelve (subtract 6 2))) ; This assigns the variable myvar, to the result of adding the variable twelve to the result of subtracting 2 from 6
 (log myvar) ; This logs the value of myvar
 (log scopelol)
 (repeat scopelol (log 10))
 (if (eq 2 scopelol) (log "2 == scopelol") | (log "2 != scopelol"))
+(log (str::concat "Hello " "World!"))

fizzbuzz.mc

+(include str)
 (def fizzbuzz
   (assign i 1)
   (repeat $1
-    (if (eq (modulo i 3) 0) (if (eq (modulo i 5) 0) (log "FizzBuzz") | (log "Fizz")))
-    (if (eq (modulo i 5) 0) (log "Buzz") | (log i))
+    (assign result "")
+    (if (eq (modulo i 3) 0) (assign result (str::concat result "Fizz")))
+    (if (eq (modulo i 5) 0) (assign result (str::concat result "Buzz")))
+    (if (eq result "") (assign result i))
+    (log result)
     (assign i (add i 1))
   )
 )

stdlib.js

     function_defs[prop.name] = body;
   },
   repeat: function (amount, body) {
-    for (i = 0 ; i < amount.value; i++) {
-        body() 
+    for (ii = 0 ; ii < amount.value; ii++) {
+        body.bind(_)() 
     }
   },
   eQ: function (arg1, arg2) {
   },
   if: function (pred, body_true, body_false) {
     if (pred.value) {
-      body_true()
+      body_true.bind(_)()
     } else {
       if (body_false) {
-        body_false()
+        body_false.bind(_)()
       }
     }
   },
+  and: function (pred1, pred2) {
+    return pred1 && pred2
+  },
+  or: function (pred1, pred2) { 
+    return pred1 || pred2
+  },
   modulo: function (arg1, arg2) {
     return {
       value: (arg1.value % arg2.value)
   }
 }
 
-const _ = new Proxy({}, my_handler)
+const proxy_obj = new Proxy({}, my_handler)
+let _
 
-module.exports = _
+module.exports = function (self) {
+  _ = self
+  return proxy_obj
+}

lib/str.js

+const global_obj = {}
+const function_defs = {}
+const warnings = {}
+const builtins = {
+  concat: function () {
+    let str = ""
+    for (i = 0; i < arguments.length; i++) {
+      str += arguments[i].value
+    }
+    return {
+      value: str
+    }
+  }
+}
+
+const my_handler = {
+  get: function (target, prop) {
+    let methods = Object.keys(builtins)
+    if (methods.includes(prop)) {
+      return builtins[prop]
+    } else {
+      console.error("Undefined function call! No such function: ", prop)
+    }
+  }, 
+  set: function (target, prop, data) {
+    if (prop === 'w') data.map((w) => warnings.w = true)
+    else console.error("Attempting to set unknown property on interpreter! How did you do that?")
+  }
+}
+
+const proxy_obj = new Proxy({}, my_handler)
+let _
+
+module.exports = function (self) {
+  _ = self
+  return proxy_obj
+}