Remove resolver and compiler, add define to parser

src/ast/functionDefinition.js

@@ -0,0 +1,7 @@
+const Node = require("./node");
+
+module.exports = class FunctionDefinition extends Node {
+  constructor(opts) {
+    super(opts);
+  }
+};

src/ast/index.js

@@ -2,6 +2,7 @@ const Application = require("./application");
 const Attribute = require("./attribute");
 const Boolean = require("./boolean");
 const Identifier = require("./identifier");
+const FunctionDefinition = require("./functionDefinition");
 const List = require("./list");
 const Number = require("./number");
 const String = require("./string");
@@ -12,6 +13,7 @@ module.exports = {
   Attribute: Attribute,
   Boolean: Boolean,
   Identifier: Identifier,
+  FunctionDefinition: FunctionDefinition,
   List: List,
   Number: Number,
   String: String,

src/compiler.js

@@ -1,58 +0,0 @@
-const selfClosingTags = require("./util/selfClosingTags");
-
-module.exports = class Compiler {
-  constructor(tree, context) {
-    this.tree = tree;
-    this.context = context;
-    this.pos = 0;
-    this.result = "";
-  }
-
-  compile() {
-    this.tree.forEach(node => {
-      switch (node.constructor.name) {
-        case "Application":
-          this.result += this.application(node);
-          break;
-        case "Number":
-        case "String":
-          this.result += node.value;
-          break;
-      }
-    });
-
-    return this.result;
-  }
-
-  application(node) {
-    let result = `<${node.functionName.name}`;
-
-    node.args
-      .filter(arg => arg.constructor.name === "Attribute")
-      .forEach(arg => {
-        result += ` ${arg.name}`;
-
-        let compiler = new Compiler([arg.value], this.context);
-        let attrValue = compiler.compile();
-
-        if (attrValue) {
-          result += `="${attrValue}"`;
-        }
-      });
-
-    result += ">";
-
-    node.args
-      .filter(arg => arg.constructor.name !== "Attribute")
-      .forEach(arg => {
-        let compiler = new Compiler([arg], this.context);
-        result += compiler.compile();
-      });
-
-    if (!selfClosingTags.includes(node.functionName.name)) {
-      result += `</${node.functionName.name}>`;
-    }
-
-    return result;
-  }
-};

src/index.js

@@ -1,7 +1,5 @@
 const Lexer = require("./lexer");
 const Parser = require("./parser");
-const Resolver = require("./resolver");
-const Compiler = require("./compiler");
 
 module.exports = function oslo(source, context) {
   const lexer = new Lexer();
@@ -9,18 +7,5 @@ module.exports = function oslo(source, context) {
   const parser = new Parser(tokens);
   const tree = parser.parse();
 
-  if (tree.error) {
-    return tree;
-  }
-
-  const resolver = new Resolver();
-  const resolvedTree = resolver.resolve(tree, context);
-
-  const util = require("util");
-
-  console.log(util.inspect(resolvedTree, { depth: null }));
-  process.exit();
-
-  const compiler = new Compiler(tree);
-  return compiler.compile();
+  return tree;
 };

src/lexer.js

@@ -44,6 +44,13 @@ module.exports = class Lexer {
           value: value
         });
         pos += value.length + 1; // the +1 is to account for the apostrophe
+      } else if (source[pos].match(/\,/)) {
+        tokenStream.tokens.push({
+          type: tokenTypes.COMMA,
+          line: line,
+          value: value
+        });
+        pos += 1;
       } else if (source[pos].match(/\d/)) {
         let number = "";
         while (source[pos] && source[pos].match(/\d/)) {

src/parser.js

@@ -1,7 +1,5 @@
-const Error = require("./Error");
-
 const AST = require("./ast");
-
+const Error = require("./Error");
 const tokenTypes = require("./tokenTypes");
 
 module.exports = class Parser {
@@ -12,7 +10,8 @@ module.exports = class Parser {
   parse() {
     let tree = [];
     while (this.tokenStream.peek().type !== tokenTypes.EOF) {
-      tree.push(this.expr());
+      let expr = this.expr();
+      tree.push(expr);
       if (this.tokenStream.error) {
         return {
           error: this.tokenStream.error
@@ -50,13 +49,21 @@ module.exports = class Parser {
   form() {
     this.tokenStream.eat(tokenTypes.OPAREN);
 
-    let node = new AST.Application();
+    let node;
 
-    node.functionName = this.identifier();
-    node.args = [];
+    if (this.tokenStream.peek().value === "define") {
+      this.tokenStream.eat(tokenTypes.IDENTIFIER);
 
-    while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
-      node.args.push(this.expr());
+      node = this.functionDefinition();
+    } else {
+      node = new AST.Application();
+
+      node.functionName = this.identifier();
+      node.args = [];
+
+      while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
+        node.args.push(this.expr());
+      }
     }
 
     this.tokenStream.eat(tokenTypes.CPAREN);
@@ -77,6 +84,36 @@ module.exports = class Parser {
     });
   }
 
+  functionDefinition() {
+    let name = new AST.Identifier({
+      name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value
+    });
+
+    let parameters = [];
+
+    this.tokenStream.eat(tokenTypes.OPAREN);
+
+    while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
+      parameters.push(
+        new AST.Identifier({
+          name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value
+        })
+      );
+
+      if (this.tokenStream.peek().type === tokenTypes.COMMA) {
+        this.tokenStream.eat(tokenTypes.COMMA);
+      }
+    }
+
+    this.tokenStream.eat(tokenTypes.CPAREN);
+
+    return new AST.FunctionDefinition({
+      name: name,
+      parameters: parameters,
+      body: this.form()
+    });
+  }
+
   identifier() {
     return new AST.Identifier({
       name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value

src/resolver.js

@@ -1,192 +0,0 @@
-const AST = require("./ast");
-
-module.exports = class Resolver {
-  constructor() {
-    this.tree = [];
-    this.context = {};
-
-    this.stdlib = {
-      if: (predicate, left, right) => {
-        const resolvedPredicate = this.resolveNode(predicate);
-
-        this.typecheck(resolvedPredicate, AST.Boolean);
-
-        if (resolvedPredicate && resolvedPredicate.value === true) {
-          return this.resolveNode(left);
-        } else if (resolvedPredicate && resolvedPredicate.value === false) {
-          return this.resolveNode(right);
-        }
-      },
-      list: args => {
-        let elements = [];
-
-        args.forEach(arg => {
-          elements.push(this.resolveNode(arg));
-        });
-
-        return new AST.List({
-          elements: elements
-        });
-      },
-      quote: value => {
-        return new AST.Symbol({ value: value });
-      },
-      htmlElement: node => {
-        let resolvedArgs = [];
-
-        node.args.forEach(arg => {
-          resolvedArgs.push(this.resolveNode(arg));
-        });
-
-        return new AST.Application({
-          functionName: node.functionName,
-          args: resolvedArgs
-        });
-      },
-      "=": (left, right) => {
-        this.typecheck(right, left.constructor);
-
-        if (left.constructor.name === "List") {
-          if (left.elements.length !== right.elements.length) {
-            return new AST.Boolean({ value: false });
-          }
-
-          let equal = true;
-
-          left.elements.forEach((el, i) => {
-            this.typecheck(el.value, right.elements[i].constructor);
-            if (el.value !== right.elements[i].value) {
-              equal = false;
-            }
-          });
-
-          return new AST.Boolean({ value: equal });
-        }
-
-        return new AST.Boolean({ value: left.value === right.value });
-      },
-      ">": (left, right) => {
-        this.typecheck(left, AST.Number) && this.typecheck(right, AST.Number);
-        return new AST.Boolean({ value: left.value > right.value });
-      },
-      "<": (left, right) => {
-        this.typecheck(left, AST.Number) && this.typecheck(right, AST.Number);
-        return new AST.Boolean({ value: left.value < right.value });
-      },
-      ">=": (left, right) => {
-        this.typecheck(left, AST.Number) && this.typecheck(right, AST.Number);
-        return new AST.Boolean({ value: left.value >= right.value });
-      },
-      "<=": (left, right) => {
-        this.typecheck(left, AST.Number) && this.typecheck(right, AST.Number);
-        return new AST.Boolean({ value: left.value <= right.value });
-      },
-      and: args => {
-        let and = true;
-
-        args.forEach(arg => {
-          this.typecheck(arg, AST.Boolean);
-          if (arg.value === false) {
-            and = false;
-          }
-        });
-
-        return new AST.Boolean({ value: and });
-      },
-      or: args => {
-        let or = false;
-
-        args.forEach(arg => {
-          this.typecheck(arg, AST.Boolean);
-          if (arg.value === true) {
-            or = true;
-          }
-        });
-
-        return new AST.Boolean({ value: or });
-      },
-      lambda: function(parameter, body) {
-        console.log(parameter, body);
-      }
-    };
-  }
-
-  resolve(tree, context) {
-    this.context = context;
-
-    tree.forEach(node => {
-      this.tree.push(this.resolveNode(node));
-    });
-
-    return this.tree;
-  }
-
-  resolveNode(node, context) {
-    if (!context) {
-      context = this.context;
-    }
-
-    switch (node.constructor.name) {
-      case "Boolean":
-      case "Number":
-      case "String":
-        return node;
-      case "Attribute":
-        return new AST.Attribute({
-          name: node.name,
-          value: this.resolveNode(node.value)
-        });
-      case "Identifier":
-        return this.lookup(node.name);
-      case "Application":
-        if (this.stdlib.hasOwnProperty(node.functionName.name)) {
-          const f = this.stdlib[node.functionName.name];
-
-          if (["list", "and", "or"].includes(node.functionName.name)) {
-            return f(node.args);
-          }
-
-          let resolvedArgs = [];
-
-          if (node.functionName.name === "quote") {
-            resolvedArgs = node.args;
-          } else {
-            node.args.forEach(arg => {
-              resolvedArgs.push(this.resolveNode(arg));
-            });
-          }
-
-          return f(...resolvedArgs);
-        }
-
-        return this.stdlib.htmlElement(node);
-    }
-  }
-
-  lookup(name) {
-    console.log(name);
-    const result = this.context[name];
-    return this.wrap(result);
-  }
-
-  wrap(value) {
-    switch (value.constructor.name) {
-      case "String":
-        return new AST.String({ value: value });
-      case "Number":
-        return new AST.Number({ value: value });
-      case "Array":
-        return new AST.List({ elements: value.map(this.wrap) });
-    }
-  }
-
-  typecheck(value, type) {
-    console.log(value);
-    console.log(type);
-    if (value.constructor.name !== type.name) {
-      throw `Type error: expected a ${type.name} but got a ${
-        value.constructor.name
-      }`;
-    }
-  }
-};

src/tokenTypes.js

@@ -1,13 +1,14 @@
 module.exports = {
-  OPAREN: '(',
-  CPAREN: ')',
-  KEYWORD: 'keyword',
+  ATTRIBUTE: "attribute",
+  BOOLEAN: "boolean",
+  COMMA: ",",
+  CPAREN: ")",
+  EOF: "EOF",
+  IDENTIFIER: "identifier",
+  KEYWORD: "keyword",
+  LITERAL: "literal",
+  NUMBER: "number",
+  OPAREN: "(",
   QUOTE: '"',
-  LITERAL: 'literal',
-  ATTRIBUTE: 'attribute',
-  SYMBOL: 'symbol',
-  NUMBER: 'number',
-  BOOLEAN: 'boolean',
-  IDENTIFIER: 'identifier',
-  EOF: 'EOF',
-}
+  SYMBOL: "symbol"
+};

test/compilerTest.js

@@ -1,28 +0,0 @@
-const test = require("tape");
-const helpers = require("./helpers");
-
-const tt = require("../src/tokenTypes");
-
-test("compiles a simple template", t => {
-  t.plan(1);
-  const result = helpers.compile(`
-    (div :class "foobar"
-      (p :class "bazquux" "Lorem ipsum dolor sit amet."))
-  `);
-  t.deepEqual(
-    result.replace(/\n/g, "").replace(/  +/g, ""),
-    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>'
-  );
-});
-
-test("self closing tags are respected", function(t) {
-  t.plan(1);
-  const result = helpers.compile(`
-    (meta :charset "UTF-8")
-    (img :src "test.png")
-  `);
-  t.deepEqual(
-    result.replace(/\n/g, "").replace(/  +/g, ""),
-    '<meta charset="UTF-8"><img src="test.png">'
-  );
-});

test/helpers.js

@@ -1,7 +1,5 @@
-const Compiler = require("../src/compiler");
 const Lexer = require("../src/lexer");
 const Parser = require("../src/parser");
-const Resolver = require("../src/resolver");
 
 const scan = source => {
   const lexer = new Lexer();
@@ -13,25 +11,7 @@ const parse = source => {
   return parser.parse();
 };
 
-const resolve = (source, context) => {
-  const resolver = new Resolver();
-  return resolver.resolve(parse(source), context);
-};
-
-const compile = (source, context) => {
-  const compiler = new Compiler(parse(source), context);
-  return compiler.compile();
-};
-
 module.exports = {
   scan: scan,
-  parse: parse,
-  compile: compile,
-  resolve: resolve
+  parse: parse
 };
-
-console.log(
-  require("util").inspect(resolve("(p :class pClass)", { pClass: "lorem" }), {
-    depth: null
-  })
-);

test/parserTest.js

@@ -1,53 +1,69 @@
-const test = require('tape')
-const helpers = require('./helpers')
+const test = require("tape");
+const helpers = require("./helpers");
 
-const AST = require('../src/ast/index')
-const tt = require('../src/tokenTypes')
+const AST = require("../src/ast/index");
+const tt = require("../src/tokenTypes");
 
-test('parses token stream into a tree', t => {
-  t.plan(1)
+test("parses token stream into a tree", t => {
+  t.plan(1);
   const tree = helpers.parse(`
     (div :class "foobar"
       (p :class (cond #t "primary" "secondary")))
-  `)
+  `);
 
   t.deepEqual(tree, [
     new AST.Application({
-      functionName: new AST.Identifier({ name: 'div' }),
+      functionName: new AST.Identifier({ name: "div" }),
       args: [
         new AST.Attribute({
-          name: 'class',
-          value: new AST.String({ value: 'foobar' }),
+          name: "class",
+          value: new AST.String({ value: "foobar" })
         }),
         new AST.Application({
-          functionName: new AST.Identifier({ name: 'p' }),
+          functionName: new AST.Identifier({ name: "p" }),
           args: [
             new AST.Attribute({
-              name: 'class',
+              name: "class",
               value: new AST.Application({
-                functionName: new AST.Identifier({ name: 'cond' }),
+                functionName: new AST.Identifier({ name: "cond" }),
                 args: [
                   new AST.Boolean({ value: true }),
-                  new AST.String({ value: 'primary' }),
-                  new AST.String({ value: 'secondary' }),
-                ],
-              }),
-            }),
-          ],
-        }),
-      ],
-    }),
-  ])
-})
+                  new AST.String({ value: "primary" }),
+                  new AST.String({ value: "secondary" })
+                ]
+              })
+            })
+          ]
+        })
+      ]
+    })
+  ]);
+});
 
-test('allow empty strings', t => {
-  t.plan(1)
-  const tree = helpers.parse('(p "")')
+test("allow empty strings", t => {
+  t.plan(1);
+  const tree = helpers.parse('(p "")');
 
   t.deepEqual(tree, [
     new AST.Application({
-      functionName: new AST.Identifier({ name: 'p' }),
-      args: [new AST.String({ value: '' })],
-    }),
-  ])
-})
+      functionName: new AST.Identifier({ name: "p" }),
+      args: [new AST.String({ value: "" })]
+    })
+  ]);
+});
+
+test("parses calls to define into a function definition", t => {
+  t.plan(1);
+  const tree = helpers.parse("(define plusOne (n) (+ n 1))");
+
+  t.deepEqual(tree, [
+    new AST.FunctionDefinition({
+      name: new AST.Identifier({ name: "plusOne" }),
+      parameters: [new AST.Identifier({ name: "n" })],
+      body: new AST.Application({
+        functionName: new AST.Identifier({ name: "+" }),
+        args: [new AST.Identifier({ name: "n" }), new AST.Number({ value: 1 })]
+      })
+    })
+  ]);
+});

test/resolverTest.js

@@ -1,48 +0,0 @@
-const test = require("tape");
-const helpers = require("./helpers");
-
-const AST = require("../src/ast");
-
-test("resolves an identifier in the content position", t => {
-  t.plan(1);
-
-  t.deepEqual(
-    helpers.resolve("(p text)", { text: "Lorem ipsum dolor sit amet" }),
-    [
-      new AST.Application({
-        functionName: new AST.Identifier({ name: "p" }),
-        args: [new AST.String({ value: "Lorem ipsum dolor sit amet" })]
-      })
-    ]
-  );
-});
-
-test("resolves an identifier as attribute value", t => {
-  t.plan(1);
-
-  t.deepEqual(helpers.resolve("(p :class pClass)", { pClass: "testClass" }), [
-    new AST.Application({
-      functionName: new AST.Identifier({ name: "p" }),
-      args: [
-        new AST.Attribute({
-          name: "class",
-          value: new AST.String({ value: "testClass" })
-        })
-      ]
-    })
-  ]);
-});
-
-test("resolves an identifier that points to a list", t => {
-  t.plan(1);
-
-  t.deepEqual(helpers.resolve("list", { list: [1, 2, 3] }), [
-    new AST.List({
-      elements: [
-        new AST.Number({ value: 1 }),
-        new AST.Number({ value: 2 }),
-        new AST.Number({ value: 3 })
-      ]
-    })
-  ]);
-});

test/stdlibTest.js

@@ -1,141 +0,0 @@
-const test = require("tape");
-const helpers = require("./helpers");
-
-const AST = require("../src/ast/index");
-
-test("quote", t => {
-  t.plan(3);
-
-  t.deepEqual(helpers.resolve("(quote 5)"), [
-    new AST.Symbol({
-      value: new AST.Number({
-        value: 5
-      })
-    })
-  ]);
-
-  t.deepEqual(helpers.resolve('(quote "hello")'), [
-    new AST.Symbol({
-      value: new AST.String({
-        value: "hello"
-      })
-    })
-  ]);
-
-  t.deepEqual(helpers.resolve("(quote (list 1 2 3))"), [
-    new AST.Symbol({
-      value: new AST.Application({
-        functionName: new AST.Identifier({ name: "list" }),
-        args: [
-          new AST.Number({ value: 1 }),
-          new AST.Number({ value: 2 }),
-          new AST.Number({ value: 3 })
-        ]
-      })
-    })
-  ]);
-});
-
-test("list", t => {
-  t.plan(2);
-
-  t.deepEqual(helpers.resolve("(list 1 2 3 4 5)"), [
-    new AST.List({
-      elements: [
-        new AST.Number({ value: 1 }),
-        new AST.Number({ value: 2 }),
-        new AST.Number({ value: 3 }),
-        new AST.Number({ value: 4 }),
-        new AST.Number({ value: 5 })
-      ]
-    })
-  ]);
-
-  t.deepEqual(helpers.resolve("(list (list 1 2) (list 3 4))"), [
-    new AST.List({
-      elements: [
-        new AST.List({
-          elements: [new AST.Number({ value: 1 }), new AST.Number({ value: 2 })]
-        }),
-        new AST.List({
-          elements: [new AST.Number({ value: 3 }), new AST.Number({ value: 4 })]
-        })
-      ]
-    })
-  ]);
-});
-
-test("if", t => {
-  t.plan(3);
-
-  t.deepEqual(helpers.resolve("(if #t 1 0)"), [new AST.Number({ value: 1 })]);
-
-  t.deepEqual(helpers.resolve("(if #f 1 0)"), [new AST.Number({ value: 0 })]);
-
-  t.deepEqual(helpers.resolve("(if (if #t #t #f) 1 0)"), [
-    new AST.Number({ value: 1 })
-  ]);
-});
-
-test("=", t => {
-  t.plan(6);
-
-  t.equal(helpers.resolve("(= 5 5)")[0].value, true);
-  t.equal(helpers.resolve("(= 5 6)")[0].value, false);
-  t.equal(helpers.resolve('(= "hello" "hello")')[0].value, true);
-  t.equal(helpers.resolve('(= "hello" "world")')[0].value, false);
-  t.equal(
-    helpers.resolve("(= (list #t #t #t) (list (> 5 4) (< 3 7) (= 9 9)))")[0]
-      .value,
-    true
-  );
-  t.equal(
-    helpers.resolve("(= (list #t #t #t) (list (> 5 4) (< 3 7) (= 9 10)))")[0]
-      .value,
-    false
-  );
-});
-
-test(">", t => {
-  t.plan(2);
-
-  t.deepEqual(helpers.resolve("(> 5 4)"), [new AST.Boolean({ value: true })]);
-  t.deepEqual(helpers.resolve("(> 4 5)"), [new AST.Boolean({ value: false })]);
-});
-
-test("<", t => {
-  t.plan(2);
-
-  t.deepEqual(helpers.resolve("(< 5 4)"), [new AST.Boolean({ value: false })]);
-  t.deepEqual(helpers.resolve("(< 4 5)"), [new AST.Boolean({ value: true })]);
-});
-
-test(">=", t => {
-  t.plan(3);
-
-  t.deepEqual(helpers.resolve("(>= 5 5)"), [new AST.Boolean({ value: true })]);
-  t.deepEqual(helpers.resolve("(>= 6 5)"), [new AST.Boolean({ value: true })]);
-  t.deepEqual(helpers.resolve("(>= 5 6)"), [new AST.Boolean({ value: false })]);
-});
-
-test("<=", t => {
-  t.plan(3);
-
-  t.deepEqual(helpers.resolve("(<= 5 5)"), [new AST.Boolean({ value: true })]);
-  t.deepEqual(helpers.resolve("(<= 5 6)"), [new AST.Boolean({ value: true })]);
-  t.deepEqual(helpers.resolve("(<= 6 5)"), [new AST.Boolean({ value: false })]);
-});
-
-test("and", t => {
-  t.plan(2);
-
-  t.equal(helpers.resolve("(and #t #t #t)")[0].value, true);
-  t.equal(helpers.resolve("(and #t #t #f)")[0].value, false);
-});
-
-test("or", t => {
-  t.plan(2);
-
-  t.equal(helpers.resolve("(or #f #f #f)")[0].value, false);
-  t.equal(helpers.resolve("(or #t #f #f)")[0].value, true);
-});