@fraczak/k 1.2.0 → 1.2.1

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@fraczak/k",
-    "version": "1.2.0",
+    "version": "1.2.1",
     "description": "k-language for JSON-like data transformation",
     "main": "index.js",
     "scripts": {
         "prepare": "coffee -c symbol-table.coffee; jison parser.jison",
-	"prepublishOnly": "coffee -c *.coffee; echo '#!/usr/bin/env node' | cat - k.js > k.sh; echo '#!/usr/bin/env node' | cat - repl.js > repl.sh;", 
+        "prepublishOnly": "coffee -c *.coffee; echo '#!/usr/bin/env node' | cat - k.js > k.sh; echo '#!/usr/bin/env node' | cat - repl.js > repl.sh;",
         "all": "coffee -c *.coffee; npm run prepare; npm run prepublishOnly",
         "test": "coffee -c symbol-table.coffee; jison parser.jison; coffee test.coffee"
     },
@@ -16,7 +16,7 @@
         "k-repl": "./repl.sh"
     },
     "devDependencies": {
-        "jison": "^0.4.18",
-        "coffeescript": "^2.7.0"
+        "coffeescript": "^2.7.0",
+        "jison": "^0.4.18"
     }
 }

package/run.coffee

@@ -58,16 +58,20 @@ verify = (code, value) ->
   # representatives = run.defs.representatives
   # defCodes = JSON.stringify run.defs.codes
   # console.log {code,value, representatives, defCodes}
+  return false unless code?
   switch code.code
     when "vector"
+      return false unless Array.isArray value
       value.every (x) ->
         verify code.vector, x
     when "product"
+      return false unless "object" is typeof value
       do (fields = Object.keys(value)) ->
         return false unless fields.length is Object.keys(code.product).length
         fields.every (label) ->
           verify code.product[label], value[label]
     when "union"
+      return false unless "object" is typeof value
       do (fields = Object.keys(value)) ->
         return false unless fields.length is 1
         verify code.union[fields[0]], value[fields[0]]
@@ -77,50 +81,46 @@ verify = (code, value) ->
         codes[code] value
 
 run = (exp, value) ->
+  "use strict"
   # console.log {exp,value}
   return undefined if value is undefined
-  try 
-    switch exp.op
-      when "code"
-        return value if verify exp.code, value
-      when "identity"
-        return value
-      when "str", "int"
-        return exp[exp.op]
-      when "ref"
-        do (defn = run.defs.rels[exp.ref]?[0]) ->
-          if defn?
-            run defn, value
-          else  
-            do ( value = builtin[exp.ref] value ) -> 
-              throw new Error "Undefined" if value is undefined
-              value          
-      when "dot"
-        return value[exp.dot]
-      when "comp"
-        return exp.comp.reduce (value, exp) ->
-          value = run exp, value
-          throw new Error "Undefined" if value is undefined
-          value
-        , value
-      when "vector"
-        return exp.vector.map (exp) -> 
-          result = run exp, value
-          throw new Error "Undefined" if result is undefined
-          result
-      when "union"
-        for e in exp.union
-          result = try run e, value
-          return result unless result is undefined
-        return undefined
-      when "product"
-        return exp.product.reduce (result, {label, exp}) ->
-          do (value = run exp, value) ->
-            throw new Error "Undefined" if value is undefined
-            result[label] = value
-            result
-        , {}
-      else  
-        console.log exp.op
+  switch exp.op
+    when "code"
+      return value if verify exp.code, value
+    when "identity"
+      return value
+    when "str", "int"
+      return exp[exp.op]
+    when "ref"
+      defn = run.defs.rels[exp.ref]?[0]
+      return run defn, value if defn?
+      return builtin[exp.ref] value 
+    when "dot"
+      return value[exp.dot]
+    when "comp"
+      return exp.comp.reduce (value, exp) ->
+        run exp, value unless value is undefined
+      , value
+    when "union"
+      for e in exp.union
+        result = run e, value
+        return result unless result is undefined
+      return undefined
+    when "vector"
+      result = []
+      for e in exp.vector
+        r = run e, value
+        return if r is undefined
+        result.push r
+      return result
+    when "product"
+      result = {}
+      for {label,exp} in exp.product
+        r = run exp, value
+        return if r is undefined
+        result[label] = r
+      return result
+    else  
+      console.error exp.op
 
 module.exports = run

package/run.js

@@ -120,15 +120,24 @@
   };
 
   verify = function(code, value) {
-    // representatives = run.defs.representatives
-    // defCodes = JSON.stringify run.defs.codes
-    // console.log {code,value, representatives, defCodes}
+    if (code == null) {
+      // representatives = run.defs.representatives
+      // defCodes = JSON.stringify run.defs.codes
+      // console.log {code,value, representatives, defCodes}
+      return false;
+    }
     switch (code.code) {
       case "vector":
+        if (!Array.isArray(value)) {
+          return false;
+        }
         return value.every(function(x) {
           return verify(code.vector, x);
         });
       case "product":
+        if ("object" !== typeof value) {
+          return false;
+        }
         return (function(fields) {
           if (fields.length !== Object.keys(code.product).length) {
             return false;
@@ -138,6 +147,9 @@
           });
         })(Object.keys(value));
       case "union":
+        if ("object" !== typeof value) {
+          return false;
+        }
         return (function(fields) {
           if (fields.length !== 1) {
             return false;
@@ -155,83 +167,74 @@
   };
 
   run = function(exp, value) {
-    var e, i, len, ref, ref1, result;
+    "use strict";
+    var defn, e, i, j, k, label, len, len1, len2, r, ref, ref1, ref2, ref3, result;
     if (value === void 0) {
       // console.log {exp,value}
       return void 0;
     }
-    try {
-      switch (exp.op) {
-        case "code":
-          if (verify(exp.code, value)) {
-            return value;
-          }
-          break;
-        case "identity":
+    switch (exp.op) {
+      case "code":
+        if (verify(exp.code, value)) {
           return value;
-        case "str":
-        case "int":
-          return exp[exp.op];
-        case "ref":
-          return (function(defn) {
-            if (defn != null) {
-              return run(defn, value);
-            } else {
-              return (function(value) {
-                if (value === void 0) {
-                  throw new Error("Undefined");
-                }
-                return value;
-              })(builtin[exp.ref](value));
-            }
-          })((ref = run.defs.rels[exp.ref]) != null ? ref[0] : void 0);
-        case "dot":
-          return value[exp.dot];
-        case "comp":
-          return exp.comp.reduce(function(value, exp) {
-            value = run(exp, value);
-            if (value === void 0) {
-              throw new Error("Undefined");
-            }
-            return value;
-          }, value);
-        case "vector":
-          return exp.vector.map(function(exp) {
-            var result;
-            result = run(exp, value);
-            if (result === void 0) {
-              throw new Error("Undefined");
-            }
+        }
+        break;
+      case "identity":
+        return value;
+      case "str":
+      case "int":
+        return exp[exp.op];
+      case "ref":
+        defn = (ref = run.defs.rels[exp.ref]) != null ? ref[0] : void 0;
+        if (defn != null) {
+          return run(defn, value);
+        }
+        return builtin[exp.ref](value);
+      case "dot":
+        return value[exp.dot];
+      case "comp":
+        return exp.comp.reduce(function(value, exp) {
+          if (value !== void 0) {
+            return run(exp, value);
+          }
+        }, value);
+      case "union":
+        ref1 = exp.union;
+        for (i = 0, len = ref1.length; i < len; i++) {
+          e = ref1[i];
+          result = run(e, value);
+          if (result !== void 0) {
             return result;
-          });
-        case "union":
-          ref1 = exp.union;
-          for (i = 0, len = ref1.length; i < len; i++) {
-            e = ref1[i];
-            result = (function() {
-              try {
-                return run(e, value);
-              } catch (error) {}
-            })();
-            if (result !== void 0) {
-              return result;
-            }
           }
-          return void 0;
-        case "product":
-          return exp.product.reduce(function(result, {label, exp}) {
-            return (function(value) {
-              if (value === void 0) {
-                throw new Error("Undefined");
-              }
-              result[label] = value;
-              return result;
-            })(run(exp, value));
-          }, {});
-        default:
-          return console.log(exp.op);
-      }
-    } catch (error) {}
+        }
+        return void 0;
+      case "vector":
+        result = [];
+        ref2 = exp.vector;
+        for (j = 0, len1 = ref2.length; j < len1; j++) {
+          e = ref2[j];
+          r = run(e, value);
+          if (r === void 0) {
+            return;
+          }
+          result.push(r);
+        }
+        return result;
+      case "product":
+        result = {};
+        ref3 = exp.product;
+        for (k = 0, len2 = ref3.length; k < len2; k++) {
+          ({label, exp} = ref3[k]);
+          r = run(exp, value);
+          if (r === void 0) {
+            return;
+          }
+          result[label] = r;
+        }
+        return result;
+      default:
+        return console.error(exp.op);
+    }
   };
 
   module.exports = run;

package/Examples/bnat.k

@@ -1,121 +0,0 @@
--- Standard binary encoding of natural
--- numbers with addition (+).
-
-_ = {{} _};
-_1 = {() "1"};
-_0 = {() "0"};
-
-n0 = _ ;
-n1 = _ _1;
-
-from_digit = <
-    [0, ()] EQ _,               -- {_: {}}
-    [1, ()] EQ n1,              -- {"1": {_: {}}}
-    [2, ()] EQ _ _0 _1,         -- {"1": {"0": {_: {}}}}
-    [3, ()] EQ _ _1 _1,         -- {"1": {"1": {_: {}}}}
-    [4, ()] EQ _ _0 _0 _1,      -- {"1": {"0": {"0": {_: {}}}}}
-    [5, ()] EQ _ _1 _0 _1,
-    [6, ()] EQ _ _0 _1 _1,
-    [7, ()] EQ _ _1 _1 _1,
-    [8, ()] EQ _ _0 _0 _0 _1,
-    [9, ()] EQ _ _1 _0 _0 _1,
-    [10, ()] EQ _ _0 _1 _0 _1
->;
-
-to_digit = <
-                  ._  0,
-              ."1"._  1,
-          ."1"."0"._  2,
-          ."1"."1"._  3,
-      ."1"."0"."0"._  4,
-      ."1"."0"."1"._  5,
-      ."1"."1"."0"._  6,
-      ."1"."1"."1"._  7,
-  ."1"."0"."0"."0"._  8,
-  ."1"."0"."0"."1"._  9,
-  ."1"."0"."1"."0"._ 10,
-  ."1"."0"."1"."1"._ 11,
-  ."1"."1"."0"."0"._ 12,
-  ."1"."1"."0"."1"._ 13,
-  ."1"."1"."1"."0"._ 14,
-  ."1"."1"."1"."1"._ 15
-> ;
-
-remove_leading_zeros =
-      < ."0" remove_leading_zeros, () >;
-
-_append_zero =
-     < ._ _ _0,          -- ( _ ->  0 _)
-       ."1" _append_zero _1,  -- ('1 ... -> '1 [$.1 | _append_zero]),
-       ."0" _append_zero _0   -- ('0 ... -> '0 [$.0 | _append_zero]),
-     >
-;
-
-_append_one =
-     <
-        ._ _ _1,
-        ."1" _append_one _1,
-        ."0" _append_one _0
-     >
-;
-
-reverse_bnat = {() x, _ y} _reverse_bnat;
-
-_reverse_bnat =
-<
-  {.x._ x, .y y} .y,
-  {.x."0" x, .y _0 y} _reverse_bnat,
-  {.x."1" x, .y _1 y} _reverse_bnat
->;
-
-_add2wc =
--- least significant bit first addition with carry
---- :{ :bnat x, :bnat y, :[0,1] c}
-    -- _log!
-    <
-      {.x."0" x, .y."0" y, .c."0" c} {.x x, .y y, _ _0 c} _add2wc _0,
-      {.x."0" x, .y."0" y, .c."1" c} {.x x, .y y, _ _0 c} _add2wc _1,
-
-      {.x."0" x, .y."1" y, .c."0" c} {.x x, .y y, _ _0 c} _add2wc _1,
-      {.x."0" x, .y."1" y, .c."1" c} {.x x, .y y, _ _1 c} _add2wc _0,
-      
-      {.x."1" x, .y."0" y, .c."0" c} {.x x, .y y, _ _0 c} _add2wc _1,
-      {.x."1" x, .y."0" y, .c."1" c} {.x x, .y y, _ _1 c} _add2wc _0,
-      
-      {.x."1" x, .y."1" y, .c."0" c} {.x x, .y y, _ _1 c} _add2wc _0,
-      {.x."1" x, .y."1" y, .c."1" c} {.x x, .y y, _ _1 c} _add2wc _1,
-      {.x._ x, .c."0" c, .y y} .y,
-      {.y._ y, .c."0" c, .x x} .x,
-      {.x._ x, .c."1" c, .y._ y} n1,
-      {.x._ x, .y."0" y, .c."1" c} .y _1,
-      {.x."0" x, .y._ y, .c."1" c} .x _1,
-      {.x._ x, .y."1" y, .c."1" c} {_ x, .y y, {} _1 c} _add2wc _0,
-      {.x."1" x, .y._ y, .c."1" c} {.x x, _ y, {} _1 c} _add2wc _0      
->;
-
-plus = <
-  SNOC { 
-    x: .0 from_digit remove_leading_zeros reverse_bnat,
-    y: .1 plus remove_leading_zeros reverse_bnat,
-    c: {} _0 } _add2wc reverse_bnat,
-  .0 from_digit
->;
-
-to_string = <
-  ._ "0",
-  toString
->;
-
-toString = <
-  ._ "",
-  ["0", ."0" toString] CONCAT,
-  ["1", ."1" toString] CONCAT
->;
-
-[(), plus] 
-{
-  input: .0,
-  sum: {raw: .1, digits: .1 <to_digit,"...too big...">, binary: .1 to_string}
-} 
-
--- example: > echo '[9,9,9,8]' | ./k.sh -k ./bnat.k  

package/Examples/code.k

@@ -1,21 +0,0 @@
-inc = [(),1] PLUS;
-max = <GT .0, .1>;  -- select max from vector of two
--- Finding a max in any vector would be: 
---   max = < SNOC [.0, .1 max] <GT .0, .1>, .0 >;
-$tree = < string leaf, {tree left, tree right} tree>;
-height =  $tree <
-  .leaf 0,
-  .tree [.left height, .right height] max inc
-> $int;
-
-<$tree, 
-  {tree:
-    { left: { leaf: "a"},
-      right: { tree:
-              {   left: {leaf: "b"},
-                  right: {leaf: "c"}
-              }
-          }
-    }
-  }
-> _log! height

package/Examples/error.k

@@ -1,8 +0,0 @@
-
-$ var = < int int, bool bool >;
-
- < 
-  $var "VAR",
-  _log! 
-  $ < int i, bool j> " < int i, bool j>"
-> 

package/Examples/factorial.k

@@ -1,12 +0,0 @@
--- factorial.k
--- E.g.:
---    > echo "5" | ./k.sh -k factorial.k
---    {"x":5,"x!":120}
-
-dec = [(),1] MINUS;
-zero? = [(),0] EQ;
-factorial = <
-  zero? 1, 
-  [dec factorial, ()] TIMES
->;
-{ () x, factorial "x!" }

package/Examples/fib.k

@@ -1,17 +0,0 @@
-pos? = [(), 0] GT .0;
-dec = [(), -1] PLUS;
-fib_aux =
-  <
-    { .n pos? dec n,
-      ."fib(n),fib(n-1),..." [[.0,.1] PLUS, ()] CONS "fib(n),fib(n-1),..."
-    } fib_aux,
-    ."fib(n),fib(n-1),..."
-  >
-;
-
-fib = {() n, [1,1] "fib(n),fib(n-1),..."}
-  fib_aux _log! .0;
-
-----------------------
-
-fib

package/Examples/pow.k

@@ -1,7 +0,0 @@
-
-pow = 
-  < [(), 0] EQ 1,
-    [[(), -1] PLUS pow, ()] TIMES
-  >;
-
-pow

package/Examples/rec-code.k

@@ -1,80 +0,0 @@
-$ t = < { t l, int v, t r } t, {} _ >;
-
-t = 
-$ {t l, int v, t r} 
-  {() t} 
-$ t
-;
-
-empty = {{} _} $t;
-
-leave = 
-$ int 
-  { empty l, 
-    () v, 
-    empty r 
-  } t 
-$ t
-; 
-
-sort = 
-$ [ int ]
-  <
-    SNOC { .0 x, .1 sort t } insert,
-    { empty l, .0 v, empty r } t,
-    empty
-  >
-$ t
-;
-
-insert = 
-$ { int x, t t } 
-  <
-    [.t._ , .x leave ] .1,
-    [[.x, .t.t.v] GT .0, .t.t]
-        { 
-            .1.l l,
-            .1.v v,
-            {.0 x, .1.r t} insert r  
-        } t,
-    { 
-        {.x x, .t.t.l t} insert l,  
-        .t.t.v v,
-        .t.t.r r  
-    } t
-  >
-$ t
-;
-
-inc = $int [(),1] PLUS $int;
-len = 
- < SNOC .1 len inc,
-   .0 1,
-   0
- >
-;
-
-concat = 
-$ [ [ int ] ] 
-  < 
-    SNOC 
-      < [.0 SNOC, .1] [.0.0, [.0.1, .1] CONS concat ] CONS,
-        [.0.0, .1 concat] CONS,
-        .1 concat
-      >,
-    .0,
-    []
-  >
-$ [ int ]
-; 
-
-toVector = 
-$ t 
-  < ._ [],
-    .t [.l toVector, [.v], .r toVector] concat
-  >
-$ [ int ] 
-;
-
-[len, sort toVector]
-

package/Examples/test.k

@@ -1,13 +0,0 @@
- ---------  comments start by #, --, or // ----------------------------------
-<                          -- merge of 4 partial functions...
-  ["x=", .x, " & y=", .y], -- produces a vector of 4 values, if fields 'x' and 'y' are present
-  ["only x=", .x],         -- produces a pair '["only x=", "value-of-x"]', for input like {"x":"value-of-x"}
-							             -- it is defined only if field 'x' is present
-  ["only y=", .y],
-  ["no x nor y"]           -- defined for all input, returns always the same one element vector
-> 
--- one of the string vectors is passed to the following partial function, 
--- which produces a record (map) with one field "x&y", whose value is the
--- result of concatenating elements of the passed in vector
-{ CONCAT "x&y" } 
-------------------------------------------------------------------------------

package/Examples/typed-fib.k

@@ -1,19 +0,0 @@
-inc = [(),1] PLUS;
-fib2 =
-$ { int target, int x, int "fib(x)", int "fib(x-1)" }
-  _log!
-  <
-    {[.target,.x]GT.0 target ,
-     .x inc x ,
-     [."fib(x)",."fib(x-1)"]PLUS "fib(x)" ,
-     ."fib(x)" "fib(x-1)" }
-    fib2,
-    
-    {[.target,.x] EQ, ."fib(x)" result}
-    .result
-  >
-$ int;
-
-{() target, 0 x, 1 "fib(x)", 0 "fib(x-1)"} fib2
- 
-