@fraczak/k 1.0.1 → 1.1.1

package/README.md

@@ -1,6 +1,6 @@
 # k-language 
 
-Another JSON-to-JSON transformation notation.  A `k`-expression
+Another JSON transformation notation.  A `k`-expression
 (script) defines a __partial function__, i.e., a function which, in
 general, is not defined for every input. `k`-expressions can be
 combined to build other `k`-expressions in three ways:
@@ -11,14 +11,15 @@ combined to build other `k`-expressions in three ways:
 	
 	Apart from empty composition, `()`, which defines _identity_, the paranthesis can be omitted.
 
-2. product, e.g., vector:
+2. product, e.g., vector or structure:
 
         [ E1, E2, E3, ... ]
-   
-    or structure:
-  
         { E1 "e1", E2 "e2", E3 "e3", ... }
 
+  Now, structure can also be written similarly to JSON, ie., 
+  
+		{ e1: E1, e2: E2, e3: E3, ... }
+
 3. union (merge), e.g.:
 
         < E1, E2, E3, ... >
@@ -42,15 +43,14 @@ Elementary partial functions are:
 		'another "String"'
 		123
 		false
-
-	Those functions are always defined, i.e., they ignore their argument.
+		null
 	
 3.  There is a number of built-in functions: `GT`, `EQ`, `PLUS`,
-	`TIMES`, `MINUS`, `DIV`, `CONCAT`, `toJSON`, `fromJSON`. For example
+	`TIMES`, `MINUS`, `DIV`, `CONCAT`, `toJSON`, `fromJSON`, `CONS`, `SNOC`. For example
 	
-		[1, 2, 3] PLUS       --> integer constant 6
-		[4, 4] TIMES toJSON  --> string constant "16"
-		[3, 2] GT            --> vector constant [3, 2]
+		[1, 2, 3] PLUS       --> integer constant function 6
+		[4, 4] TIMES toJSON  --> string constant function "16"
+		[3, 2] GT            --> vector constant function [3, 2]
 		[3, 4] GT            --> is not defined!
 		
 	A more interesting example could be:
@@ -61,6 +61,47 @@ Elementary partial functions are:
 	
 		[3,8] < [.0, .1] GT, [.1, .0] GT > .0    --> 8
 
+## User defined functions
+
+`k`-expression can be prefixed by function definitions. E.g.: 
+
+	dec = [(),1] MINUS;
+	factorial = <
+	  [1,()] GT 1,
+	  [dec factorial, ()] TIMES
+	>;
+	{ () x, factorial "x!" }
+
+## Value encodings (also called _types_ or _codes_)
+
+There are three predefined value encodings: `int`, `string`, and `bool`. The language
+supports `code`-expressions:
+
+* product, e.g., `{int x, int y, bool flag}` (in JSON-like syntax `{x: int, y: int, flag: bool}`)
+* disjoint union, e.g., `<{} true, {} false>` (in JSON-like syntax `<true: {}, false: {}>`)
+* vector, e.g., `[ int ]` (all elements of the vector use the same encoding)
+
+One can define recursive codes. E.g.:
+
+	$ tree = <string leaf, {tree left, tree right} tree>;
+
+or, the same in JSON-like notation:
+
+	$ tree = <leaf: string, tree: {left: tree, right: tree}>;
+
+Each _code_ definition starts with a `$`.
+The above example defines new code called _tree_.
+
+The code can be then used in a `k`-expression as a filter. A `code`-expression
+within `k`-expression is again prefixed by `$`.
+
+	$tree = <string leaf, {tree left, tree right} tree>;
+	inc = [(),1] PLUS;
+	height = $ tree <
+		.leaf 0,
+		.tree [.left height, .right height] <GT .0, .1> inc
+	> $ int;
+	height
 
 
 ## Command line script
@@ -70,7 +111,7 @@ run the language from command line.
 
     $ ./node_modules/.bin/k
 	... errors ...
-	Usage: ./node_modules/.bin/k ( k-expr | -k k-file) [ json-file ]
+	Usage: ./node_modules/.bin/k ( k-expr | -k k-file) [ -1 ] [ json-file ]
 	       E.g., cat '{"a": 10}' | ./node_modules/.bin/k '[(),()]'
 
 ### Examples
@@ -113,7 +154,7 @@ run the language from command line.
 	
 	If we want to read `json` objects from a file, e.g., `my-objects.json`, we do
 	
-		$ ./k.coffee -k test.k -j my-objects.json
+		$ ./k.coffee -k test.k my-objects.json
 		{"x&y":"x=432 & y=123"} 
 		{"x&y":"onlyx=987"} 
 		{"x&y":"no x nor y"}
@@ -178,4 +219,3 @@ run the language from command line.
 
     k_fn({"age":2,"name":"Mark"})
     // RETURNS: {"nom":"Mark","age":"enfant"}
-

package/bnat.k

@@ -0,0 +1,121 @@
+-- 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/code.k

@@ -0,0 +1,18 @@
+inc = [(),1] PLUS;
+$tree = < string leaf, {tree left, tree right} tree>;
+height =  $tree <
+    .leaf 0,
+    .tree [.left height, .right height] <GT .0, .1> inc
+> $int;
+
+<$tree, 
+  {tree:
+    { left: { leaf: "a"},
+      right: { tree:
+              {   left: {leaf: "b"},
+                  right: {leaf: "c"}
+              }
+          }
+    }
+  }
+> _log! height

package/codes.coffee

@@ -0,0 +1,107 @@
+
+are_different = (classes, representatives, name1, name2, codes) ->
+  return false if name1 is name2
+  code1 = codes[name1]
+  code2 = codes[name2]
+  # console.log {name1, code1, name2, code2}
+  return true unless code1.code is code2.code
+  switch code1.code
+    when "union", "product"
+      [fields1,fields2] = [code1, code2]. map (code) ->
+        Object.keys(code[code.code]).reduce (fields, label) ->
+          fields[label] = representatives[code[code.code][label]]
+        , {}
+      return true unless Object.keys(fields1).length is Object.keys(fields2).length
+      for field,rep of fields1 
+        return true unless fields2[field] is rep 
+      return false
+    when "vector"
+      return representatives[code1.vector] isnt representatives[code2.vector]  
+  false
+
+minimize = (codes) ->
+  names = Object.keys codes
+  classes = {}
+  classes["{}"] = names
+  representatives = names.reduce (representatives, name) ->
+    representatives[name] = "{}"
+    representatives
+  , {}
+  changed = true
+  while changed
+    changed = false
+    for name1, eq_names of classes
+      code = codes[name1]
+      [eq_names, dif_names] = eq_names.reduce ([eq_names, dif_names], name2) ->
+        if are_different(classes, representatives, name1, name2, codes)
+          dif_names.push name2
+        else
+          eq_names.push name2
+        [eq_names,dif_names]
+      , [[],[]]
+      classes[name1] = eq_names
+      do (new_rep = dif_names[0]) ->
+        if new_rep?
+          changed = true
+          classes[new_rep] = dif_names
+          for x in dif_names
+            representatives[x] = new_rep
+  {classes,representatives}
+
+compareAs = (fn) ->
+  (a,b) -> 
+    [a,b] = [a,b].map fn
+    return -1 if a < b
+    return 1 if a > b
+    0 
+
+pretty_labels = (label_ref_map, codes, representatives) ->
+  labels = Object.keys(label_ref_map)
+  .sort compareAs (x) -> x
+  .map (label) ->
+    "#{pretty {code:"ref",ref:label_ref_map[label]}, codes, representatives} #{label}"
+  .join ", "
+
+pretty = (codeExp, codes, representatives) ->
+  switch codeExp.code 
+    when "ref"
+      name = representatives[codeExp.ref] ? codeExp.ref
+      if name.startsWith ":"
+        pretty codes[name], codes, representatives
+      else
+        name
+    when "product"
+      "{#{pretty_labels codeExp.product, codes, representatives}}"
+    when "union"
+      "<#{pretty_labels codeExp.union, codes, representatives}>"
+    when "vector"
+      "[#{representatives[codeExp.ref] ? codeExp.ref}]"
+    else    
+      ":error"
+
+normalize = (label_ref_map, representatives) ->
+  # console.log {label_ref_map, representatives}
+  Object.keys(label_ref_map).reduce (result, label) ->
+    result[label] = do (name = label_ref_map[label]) ->
+      representatives[name] ? name
+    result
+  , {}
+
+normalizeAll = (codes,representatives) ->
+  names = Object.keys codes
+  normalized = names.reduce (normalized, name) ->
+    if name is representatives[name]
+      do (code = codes[name]) ->
+        switch code.code
+          when "union", "product"
+            normalized[name] = { code: code.code } 
+            normalized[name][code.code] = normalize code[code.code], representatives
+          when "vector"
+            normalized[name] = {code:"vector", vector: representatives[code.vector]}
+  
+    normalized    
+  , {}
+
+module.exports = {minimize,pretty,normalize,normalizeAll}
+
+

package/codes.js

@@ -0,0 +1,167 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  var are_different, compareAs, minimize, normalize, normalizeAll, pretty, pretty_labels;
+
+  are_different = function(classes, representatives, name1, name2, codes) {
+    var code1, code2, field, fields1, fields2, rep;
+    if (name1 === name2) {
+      return false;
+    }
+    code1 = codes[name1];
+    code2 = codes[name2];
+    if (code1.code !== code2.code) {
+      // console.log {name1, code1, name2, code2}
+      return true;
+    }
+    switch (code1.code) {
+      case "union":
+      case "product":
+        [fields1, fields2] = [code1, code2].map(function(code) {
+          return Object.keys(code[code.code]).reduce(function(fields, label) {
+            return fields[label] = representatives[code[code.code][label]];
+          }, {});
+        });
+        if (Object.keys(fields1).length !== Object.keys(fields2).length) {
+          return true;
+        }
+        for (field in fields1) {
+          rep = fields1[field];
+          if (fields2[field] !== rep) {
+            return true;
+          }
+        }
+        return false;
+      case "vector":
+        return representatives[code1.vector] !== representatives[code2.vector];
+    }
+    return false;
+  };
+
+  minimize = function(codes) {
+    var changed, classes, code, dif_names, eq_names, name1, names, representatives;
+    names = Object.keys(codes);
+    classes = {};
+    classes["{}"] = names;
+    representatives = names.reduce(function(representatives, name) {
+      representatives[name] = "{}";
+      return representatives;
+    }, {});
+    changed = true;
+    while (changed) {
+      changed = false;
+      for (name1 in classes) {
+        eq_names = classes[name1];
+        code = codes[name1];
+        [eq_names, dif_names] = eq_names.reduce(function([eq_names, dif_names], name2) {
+          if (are_different(classes, representatives, name1, name2, codes)) {
+            dif_names.push(name2);
+          } else {
+            eq_names.push(name2);
+          }
+          return [eq_names, dif_names];
+        }, [[], []]);
+        classes[name1] = eq_names;
+        (function(new_rep) {
+          var i, len, results, x;
+          if (new_rep != null) {
+            changed = true;
+            classes[new_rep] = dif_names;
+            results = [];
+            for (i = 0, len = dif_names.length; i < len; i++) {
+              x = dif_names[i];
+              results.push(representatives[x] = new_rep);
+            }
+            return results;
+          }
+        })(dif_names[0]);
+      }
+    }
+    return {classes, representatives};
+  };
+
+  compareAs = function(fn) {
+    return function(a, b) {
+      [a, b] = [a, b].map(fn);
+      if (a < b) {
+        return -1;
+      }
+      if (a > b) {
+        return 1;
+      }
+      return 0;
+    };
+  };
+
+  pretty_labels = function(label_ref_map, codes, representatives) {
+    var labels;
+    return labels = Object.keys(label_ref_map).sort(compareAs(function(x) {
+      return x;
+    })).map(function(label) {
+      return `${pretty({
+        code: "ref",
+        ref: label_ref_map[label]
+      }, codes, representatives)} ${label}`;
+    }).join(", ");
+  };
+
+  pretty = function(codeExp, codes, representatives) {
+    var name, ref, ref1;
+    switch (codeExp.code) {
+      case "ref":
+        name = (ref = representatives[codeExp.ref]) != null ? ref : codeExp.ref;
+        if (name.startsWith(":")) {
+          return pretty(codes[name], codes, representatives);
+        } else {
+          return name;
+        }
+        break;
+      case "product":
+        return `{${pretty_labels(codeExp.product, codes, representatives)}}`;
+      case "union":
+        return `<${pretty_labels(codeExp.union, codes, representatives)}>`;
+      case "vector":
+        return `[${(ref1 = representatives[codeExp.ref]) != null ? ref1 : codeExp.ref}]`;
+      default:
+        return ":error";
+    }
+  };
+
+  normalize = function(label_ref_map, representatives) {
+    // console.log {label_ref_map, representatives}
+    return Object.keys(label_ref_map).reduce(function(result, label) {
+      result[label] = (function(name) {
+        var ref;
+        return (ref = representatives[name]) != null ? ref : name;
+      })(label_ref_map[label]);
+      return result;
+    }, {});
+  };
+
+  normalizeAll = function(codes, representatives) {
+    var names, normalized;
+    names = Object.keys(codes);
+    return normalized = names.reduce(function(normalized, name) {
+      if (name === representatives[name]) {
+        (function(code) {
+          switch (code.code) {
+            case "union":
+            case "product":
+              normalized[name] = {
+                code: code.code
+              };
+              return normalized[name][code.code] = normalize(code[code.code], representatives);
+            case "vector":
+              return normalized[name] = {
+                code: "vector",
+                vector: representatives[code.vector]
+              };
+          }
+        })(codes[name]);
+      }
+      return normalized;
+    }, {});
+  };
+
+  module.exports = {minimize, pretty, normalize, normalizeAll};
+
+}).call(this);

package/factorial.k

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

package/fib.k

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

package/index.coffee

@@ -1,10 +1,25 @@
 fs = require "fs"
 {parse} = require "./parser.js"
 run = require "./run"
+t = require "./codes"
+
+
+finalize = (codes) ->
+  representatives = t.minimize(codes).representatives
+  codes = t.normalizeAll codes, representatives
+
+  {codes, representatives}
+
 
 compile = (script) ->
-  do (exp = parse script) ->
+  do ({defs,exp} = parse script) ->
+    # console.log defs
+    {codes, representatives} = finalize defs.codes
+    # console.log {codes, representatives}
+    run.defs = {codes, representatives, rels: defs.rels}
+    
     (data) -> run exp, data
+    
 compile.doc = "Transforms k-script (string) into a function"
 
 compile_file = (fileName) ->

package/index.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
 (function() {
-  var compile, compile_file, fs, parse, run, runScriptOnData;
+  var compile, compile_file, finalize, fs, parse, run, runScriptOnData, t;
 
   fs = require("fs");
 
@@ -8,8 +8,26 @@
 
   run = require("./run");
 
+  t = require("./codes");
+
+  finalize = function(codes) {
+    var representatives;
+    representatives = t.minimize(codes).representatives;
+    codes = t.normalizeAll(codes, representatives);
+    return {codes, representatives};
+  };
+
   compile = function(script) {
-    return (function(exp) {
+    return (function({defs, exp}) {
+      var codes, representatives;
+      // console.log defs
+      ({codes, representatives} = finalize(defs.codes));
+      // console.log {codes, representatives}
+      run.defs = {
+        codes,
+        representatives,
+        rels: defs.rels
+      };
       return function(data) {
         return run(exp, data);
       };

package/k.coffee

@@ -4,7 +4,8 @@ k = require "./"
 
 prog = process.argv[1]
 
-{kScript,jsonStream} = do (args = process.argv.slice(2)) ->
+{kScript,jsonStream,oneJson} =
+do (oneJson = false, args = process.argv.slice(2)) ->
   try 
     kScript = do (arg = args.shift()) ->
       throw new Error() unless arg?
@@ -16,30 +17,43 @@ prog = process.argv[1]
     kScript = k.compile kScript
     
     jsonStream = do (arg = args.shift()) ->
+      if arg is "-1"
+        oneJson = true
+        arg = args.shift()      
       return process.stdin unless arg?
       fs.createReadStream arg
 
-    {kScript, jsonStream}
+    {kScript, jsonStream, oneJson}
   catch e
     console.error e
-    console.error "Usage: #{prog} ( k-expr | -k k-file ) [ json-file ]"
+    console.error "Usage: #{prog} ( k-expr | -k k-file ) [ -1 ] [ json-file ]"
     console.error "       E.g.,  echo '{\"a\": 12}' | #{prog} '[(),()]'"
     process.exit -1 
 
-do (buffer = [], line = 0) ->
-  jsonStream.on 'data', (data) ->
-    [first, rest...] = data.toString("utf8").split "\n"
-    buffer.push first
-    if rest.length > 0
-      todo = buffer.join ""
-      [rest..., last] = rest
-      buffer = [last]
-      todo = [todo, rest...]
-      for json in todo
-        if not json.match /^[ \n\t]*(?:#.*)?$/
-          try
-            console.log JSON.stringify kScript JSON.parse json
-          catch e 
-            console.error "Problem [line #{line}]: '#{json}'"
-            console.error e
-        line = line + 1
+if oneJson
+  do (buffer = []) ->
+    jsonStream.on 'data', (data) ->
+      buffer.push data
+    jsonStream.on 'end', ->
+      try
+        console.log JSON.stringify kScript JSON.parse buffer.join('')
+      catch e
+        console.error e
+else
+  do (buffer = [], line = 0) ->
+    jsonStream.on 'data', (data) ->
+      [first, rest...] = data.toString("utf8").split "\n"
+      buffer.push first
+      if rest.length > 0
+        todo = buffer.join ""
+        [rest..., last] = rest
+        buffer = [last]
+        todo = [todo, rest...]
+        for json in todo
+          if not json.match /^[ \n\t]*(?:#.*)?$/
+            try
+              console.log JSON.stringify kScript JSON.parse json
+            catch e 
+              console.error "Problem [line #{line}]: '#{json}'"
+              console.error e
+          line = line + 1