Add function definitions and more example code to showcase this

compiler.js

       })
       continue
     }
+    let dollar = /[$]/
+    if (dollar.test(char)) {
+      let name = ''
+      char = input[++pos]
+      if (numbers.test(char)) {
+        while (numbers.test(char)) {
+          name += char
+          char = input[++pos]
+        }
+      } else {
+        console.error("Compiler Error: $ must be followed by a digit [0-9]")
+        process.exit(1);
+      }
+      tokens.push({
+        type: 'dollar',
+        value: name
+      })
+      continue
+    }
     throw new TypeError("I'm not sure what you are telling me :( Ask my creator to teach me what a: " + char + " is.")
   }
   return tokens
       }
     }
 
+    if (token.type === 'dollar') {
+      pos++
+      return {
+        type: 'DollarVar',
+        value: token.value
+      }
+    }
+
     if (token.type === 'paren' && token.value == '(') {
       token = input[++pos]
       if (token.type !== 'name') {
         break
       case 'NumberLiteral':
         break
+      case 'DollarVar':
+        break
       default:
         throw {
           name: 'Compiler Error',
         value: node.value
       })
     },
+    DollarVar: function (node, parent) {
+      parent._context.push({
+        type: 'DollarVar',
+        value: node.value
+      })
+    },
     FunctionCall: function (node, parent) {
       let expression = {
         type: 'FunctionCall',
       return (generator(node.expr) + ';')
       break
     case 'FunctionCall':
-      return (generator(node.callee) + '(' + node.args.map(generator).join(', ') + ')')
+      if (node.callee.name !== 'def') {
+        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 "'" + generator(v) + '; '
+            } else {
+              return generator(v) + '; '
+            }
+          }
+        }).join('') + "')")
+      }
+      break;
+    case 'DollarVar':
+      return '$' + node.value
       break
     case 'FunctionName':
       return '_.' + node.name
 const myTokens = tokenizer(myInput)
 const parsedTree = parser(myTokens)
 const transformedTree = transformer(parsedTree)
+//console.log(JSON.stringify(transformedTree,null,2))
 const output = generator(transformedTree)
 fs.writeFileSync('output.js', output)

example.mc

 (log 6) # This logs the number literal 6
 (assign twelve myvar) # This reassigns the variable twelve to the value of the variable myvar
 (log twelve) # This logs the new value of the variable twelve
+# An example function definition
+(def myF 
+  (log 0) 
+  (log twelve) 
+  (log 6) 
+  (log 6) 
+  (assign scopelol (add twelve 5)) 
+  (log scopelol)
+)
+(def argTest (log $1) (log $2)) # Functions take an unlimited number of arguments that can be referred to by $n
+(myF) # Calling an argument-less function
+(log 0)
+(log 0)
+(log 0)
+(log 0)
+(log 0)
+(log 0)
+(argTest 43 scopelol) # Custom functions with arguments are called like any other

stdlib.js

 const global_obj = {}
-module.exports = {
+const function_defs = {}
+const warnings = {}
+const builtins = {
   assign: function (ref, value) {
     if (!ref.name) {
       console.error('Argument 1 of assign must always be a VariableReference')
       name: refname,
       value: global_obj[refname]
     }
+  },
+  def: function (prop, body) {
+    let methods = Object.keys(function_defs)
+    if (methods.includes(prop.name)) {
+      console.warn("Warning! Redefining function, did you mean to do this?")
+    }
+    function_defs[prop.name] = body;
+  }
+}
+
+
+const my_handler = {
+  get: function (target, prop) {
+    let methods = Object.keys(builtins)
+    if (methods.includes(prop)) {
+      return builtins[prop]
+    } else {
+      methods = Object.keys(function_defs)
+      if (methods.includes(prop)) {
+        return (function () { eval(function_defs[prop].replace(/\$(\d+)/g, (m, n) => JSON.stringify(arguments[(+n-1)]))) })
+      } 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 _ = new Proxy({}, my_handler)
+
+module.exports = _