desugar.js

@@ -57,30 +57,34 @@ function sugarTypeDecl(stx) {
   return new typ.TypeDecl(expression, type);
 }
 
-function desugarDefType(stx) {
+function desugarDefType(stx, typeEnv) {
   var result;
-  result = new typ.DefType(desugar(stx.lhs), desugar(stx.rhs));
+  var rhs = desugar(stx.rhs);
+  var name = stx.lhs.name;
+  typeEnv[name] = rhs;
+
+  result = new typ.DefType(stx.lhs, desugar(stx.rhs));
   result.linenum = stx.linenum;
   result.charnum = stx.charnum;
   return result;
 }
 
 
-function desugar(stx) {
+function desugar(stx, typeEnv) {
  var typeExpTest;
 
  switch (stx.exprType) {
     case "If":
       if (stx.elseexp) {
-        return new typ.If(desugar(stx.condition), desugar(stx.thenexp), desugar(stx.elseexp));
+        return new typ.If(desugar(stx.condition, typeEnv), desugar(stx.thenexp, typeEnv), desugar(stx.elseexp, typeEnv));
       }
-      return new typ.If(desugar(stx.condition), desugar(stx.thenexp));
+      return new typ.If(desugar(stx.condition, typeEnv), desugar(stx.thenexp, typeEnv));
     case "FunctionDefinition":
       return desugarDefFunc(stx);
     case "Definition":
-      return new typ.Def(stx.ident, desugar(stx.val));
+      return new typ.Def(stx.ident, desugar(stx.val, typeEnv));
     case "TypeDefinition":
-      return desugarDefType(stx);
+      return desugarDefType(stx, typeEnv);
     case "Name":
       return stx;
     case "Application":
@@ -104,10 +108,10 @@ function desugar(stx) {
       if ((stx.func.ident === "-" ||
           stx.func.ident === "+") &&
           stx.p) {
-            return new typ.UnaryOp(desugar(stx.func), desugar(stx.p));
+            return new typ.UnaryOp(desugar(stx.func, typeEnv), desugar(stx.p, typeEnv));
           }
       if (stx.p) {
-        return new typ.App(desugar(stx.func), desugar(stx.p));
+        return new typ.App(desugar(stx.func, typeEnv), desugar(stx.p, typeEnv));
       }
       return new typ.App(stx.func);
     case "Function":

free_vars.js

@@ -149,8 +149,7 @@ function annotate_fvs_all(stx) {
 
 
 function test(src) {
-  var ast = parser.parse(src)[0];
+  var ast = parser.parse(src);
-  console.log(JSON.stringify(annotate_fvs_all(ast), null, 4));
 }
 
 //console.log(test("if something then if a then if b then c else d else rtrrt else some_other_thing"));

parse.js

@@ -807,11 +807,12 @@ function parse(tokens) {
 
 function parseFull(tokenized) {
   var ast = [];
+  var typeBindings = {};
   try {
     while (tokenized.length > 0) {
-      ast.push(desugarer.desugar(parse(tokenized)));
+      ast.push(desugarer.desugar(parse(tokenized), typeBindings));
     }
-    return ast;
+    return [ast, typeBindings];
   } catch (e) {
       if (e.stxerror !== undefined) {
         e.stxerror();
@@ -830,4 +831,6 @@ module.exports = { parse : function(str) {
                   tokenize : tokenizer.tokenize
                  };
 var istr = fs.readFileSync('/dev/stdin').toString();
-console.log(parseFull(tokenizer.tokenize(istr)).map(pprint.pprint));
+var testParse = parseFull(tokenizer.tokenize(istr));
+console.log(testParse[1]);
+console.log(testParse[0].map(pprint.pprint));

prelude.jl

@@ -63,56 +63,56 @@ deftype (Either a b)
 
 ;; Operator definitions
 
-defop 3 Left (a + b)
+defop 1 Left (a + b)
   (add a b)
 
-defop 3 Left (a - b)
+defop 1 Left (a - b)
   (minus a b)
 
-defop 4 Left (a * b)
+defop 2 Left (a * b)
   (mul a b)
 
-defop 4 Left (a / b)
+defop 2 Left (a / b)
   (div a b)
 
-defop 5 Right (a ^ b)
+defop 2 Right (a ^ b)
   (pow a b)
 
 defop 3 Left (a ++ b)
   (listConcat a b)
 
-defop 2 Left (a == b)
+defop 3 Left (a == b)
   (eq a b)
 
-defop 2 Left (a > b)
+defop 3 Left (a > b)
   (gt a b)
 
-defop 2 Left (a >= b)
+defop 3 Left (a >= b)
   (gte a b)
 
-defop 2 Left (a < b)
+defop 3 Left (a < b)
   (lt a b)
 
-defop 2 Left (a <= b)
+defop 3 Left (a <= b)
   (lte a b)
 
-defop 2 Left (a && b)
+defop 3 Left (a && b)
   (and a b)
 
-defop 2 Left (a || b)
+defop 3 Left (a || b)
   (or a b)
 
-defop 1 Left (x : xs)
+defop 4 Left (x : xs)
   (cons x xs)
 
-defop 1 Left (f $ x)
+defop 5 Left (f $ x)
   (fapply f x)
 
-defop 1 Left (f . g)
+defop 5 Left (f . g)
   (compose f g)
 
-defop 1 Left (a | b)
+defop 3 Left (a | b)
   (bitwiseOr a b)
 
-defop 1 Left (a & b)
+defop 3 Left (a & b)
   (bitwiseAnd a b)

tokenize.js

@@ -14,7 +14,7 @@ function isDigit(c) {
   if (isNaN(code)) {
     return false;
   }
-  return (47 < code && code < 58);
+  return (47 < code) && (code < 58)
 }
 
 function isWhitespace(c) {
@@ -411,9 +411,9 @@ function checkPattern(x, i) {
 function tokenizeFull(input) {
   var preludeSrc = fs.readFileSync("./prelude.jl");
   var matchop;
+  input = [preludeSrc, input].join("");
   var initialPass = tokenizeHelp(input, _.constant(false), true).reverse();
 
-  input = [preludeSrc, input].join("");
   for (var i = 0; i < initialPass.length; i++) {
     if (initialPass.slice(i, i+8).
         map(_.first).

typecheck.js

@@ -16,4 +16,3 @@ var env = require("./environments.js");
 /*
  * Map all bindings with explicit type annotations in the environment
  */
-function gather_annotations(stx) {