Merge pull request #60 from cheddar-lang/feature-funcop

Functionized Operators

TODO.md

@@ -0,0 +1,11 @@
+FEATURE:
+ - [x] Functionized Operators
+ - [ ] Custom REPL Colors
+ - [ ] Strict typing in assignment
+ - [ ] Static enforcement in functions
+ - [ ] Class literals
+ - [ ] Func statement
+ - [ ] Signal propogation
+ - [x] for of
+
+FIX:

src/interpreter/core/config/link.es6

@@ -12,4 +12,10 @@ export const PRIMITIVE_LINKS = new Map([
     ["CheddarNumberToken"  , CheddarNumber],
     ["CheddarArrayToken"   , CheddarArray],
     ["CheddarFunctionToken", CheddarFunc]
+]);
+
+import CheddarFunctionizedOperator from '../evaluated/fop';
+
+export const EVALUATED_LINKS = new Map([
+    ["CheddarFunctionizedOperatorToken", CheddarFunctionizedOperator]
 ]);

src/interpreter/core/eval/eval.es6

@@ -18,7 +18,7 @@
 //   itself
 
 // Primitive <-> Class Links
-import {PRIMITIVE_LINKS} from '../config/link';
+import {PRIMITIVE_LINKS, EVALUATED_LINKS} from '../config/link';
 import {TYPE as OP_TYPE, EXCLUDE_META_ASSIGNMENT as REG_OPS} from '../../../tokenizer/consts/ops';
 
 // Reference tokens
@@ -154,7 +154,7 @@ export default class CheddarEval extends CheddarCallStack {
                     OPERATOR = CheddarError.NO_OP_BEHAVIOR;
                 }
             } else {
-                // Binary operator. DATA is RHS, TOKEN is LHS
+                // Binary operator. DATA is LHS, TOKEN is RHS
                 DATA = this.shift(); // Get the other arg
 
                 NAME = DATA.constructor.Operator ||
@@ -242,8 +242,7 @@ export default class CheddarEval extends CheddarCallStack {
                 }
 
                 // Get the class associated with the token
-                OPERATOR = PRIMITIVE_LINKS.get(TOKEN.constructor.name);
-                if (OPERATOR) {
+                if ((OPERATOR = PRIMITIVE_LINKS.get(TOKEN.constructor.name))) {
                     // Set the name to be used in errors
                     NAME = OPERATOR.Name || "object";
 
@@ -258,6 +257,8 @@ export default class CheddarEval extends CheddarCallStack {
                         this.put(OPERATOR);
                         return true;
                     }
+                } else if ((OPERATOR = EVALUATED_LINKS.get(TOKEN.constructor.name))) {
+                    OPERATOR = OPERATOR(...TOKEN.Tokens);
                 } else {
                     return CheddarError.UNLINKED_CLASS;
                 }

src/interpreter/core/evaluated/fop.es6

@@ -0,0 +1,49 @@
+import CheddarFunction from '../env/func';
+import CheddarError from '../consts/err';
+import CheddarClass from '../env/class';
+import CheddarErrorDesc from '../consts/err_msg';
+
+export default function(operator) {
+    return new CheddarFunction([
+        ["a", {}],
+        ["b", {}]
+    ], function(scope, input) {
+        let LHS = input("a");
+        let RHS = input("b");
+
+        let resp; // output / response
+        let opfunc = (
+            LHS.constructor.Operator ||
+            LHS.Operator
+        ).get(operator);
+
+        if (opfunc) {
+            resp = opfunc(LHS, RHS);
+        }
+        else {
+            resp = CheddarError.NO_OP_BEHAVIOR;
+        }
+
+        if (resp === CheddarError.NO_OP_BEHAVIOR) {
+            return CheddarErrorDesc.get(resp)
+                .replace(/\$0/g, operator)
+                .replace(/\$1/g, LHS ? (
+                    LHS.constructor.Name || (
+                        LHS.prototype instanceof CheddarClass ?
+                        "Class" :
+                        "nil"
+                    )
+                ) : "nil")
+                .replace(/\$2/g, RHS ? (
+                    RHS.constructor.Name || (
+                        RHS.prototype instanceof CheddarClass ?
+                        "Class" :
+                        "nil"
+                    )
+                ) : "nil");
+        } else {
+            return resp;
+        }
+
+    });
+}

src/tokenizer/literals/fop.es6

@@ -0,0 +1,11 @@
+// Functionized operators
+import {OP} from '../consts/ops';
+import CheddarPrimitive from './primitive';
+
+export default class CheddarFunctionizedOperatorToken extends CheddarPrimitive {
+    exec() {
+        return this.grammar(true, [
+            '(', OP, ')'
+        ]);
+    }
+}

src/tokenizer/literals/op.es6

@@ -3,7 +3,6 @@ import CheddarLexer from '../tok/lex';
 import {UOP, OP} from '../consts/ops';
 
 export default class CheddarOperatorToken extends CheddarLexer {
-    // Chatse
     exec(UNARY) {
         let ops = UNARY ? UOP : OP;
         // this.Code is the code

src/tokenizer/parsers/any.es6

@@ -7,11 +7,14 @@ import CheddarStringToken from '../literals/string';
 import CheddarNumberToken from '../literals/number';
 import CheddarArrayToken from './array';
 
+import CheddarFunctionizedOperatorToken from '../literals/fop';
+
 export default class CheddarAnyLiteral extends CheddarLexer {
     exec() {
         this.open(false);
 
         let attempt = this.attempt(
+            CheddarFunctionizedOperatorToken,
             CheddarStringToken,
             CheddarNumberToken,
             CheddarBooleanToken,