@naanlang/naan 1.0.13 → 1.0.15

package/lib/env_node.js

@@ -37,6 +37,7 @@ exports.NaanNodeREPL = function NaanNodeREPL(options) {
     if (typeof(options) != 'object')
         options = { };
     var repl = require('repl');
+    var replServer;
     var process = require('process');
     var Naan = require('./core/naanlib');
     var naanlib = new Naan.Naanlib();
@@ -69,6 +70,14 @@ exports.NaanNodeREPL = function NaanNodeREPL(options) {
         outEnable = true;
         naanlib.textLine(cmd);
     };
+    
+    this.setPrompt = function setPrompt(prompt) {
+        if (replServer) {
+            replServer.setPrompt(prompt);
+            return (prompt);
+        }
+        return (false);
+    };
 
 
     //==========================================================================
@@ -85,9 +94,9 @@ exports.NaanNodeREPL = function NaanNodeREPL(options) {
     
     if (!options.replDisable)
     {
-        var nprompt = repl.start({ prompt: 'Naan> ', eval: myEval});
+        replServer = repl.start({ prompt: 'Naan> ', eval: myEval});
     
-        nprompt.on('line', function(cmd) {                                  // process raw command line
+        replServer.on('line', function(cmd) {                                  // process raw command line
             if (cmd.charAt(0) != ".") {
                 textToRemoteTerm(cmd);
                 naanlib.textLine(cmd + "\n");
@@ -98,7 +107,7 @@ exports.NaanNodeREPL = function NaanNodeREPL(options) {
         // Hook the ^C interrupt
         //
     
-        nprompt._events.SIGINT = function () {
+        replServer._events.SIGINT = function () {
             naanlib.escape();
         };
     
@@ -106,7 +115,7 @@ exports.NaanNodeREPL = function NaanNodeREPL(options) {
         // Hook an exit command
         //
     
-        nprompt.on('exit', function() {
+        replServer.on('exit', function() {
             process.exit();
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@naanlang/naan",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "author": "Richard C. Zulch",
     "description": "Naan™ software platform",
     "main": "./lib/core/naanlib.js",

package/plugins/openSearch/openSearch.nlg

@@ -32,6 +32,10 @@
  *      `number                                 -- float or integer
  *      `url                                    -- URL
  *
+ * Although the currency type is only treated as a text field for now, the intent is that these will
+ * match the RegEx /([A-Z]{3})(-?[0-9]+(?:[,.][0-9]+)?)/ so that the currency type and amount can be
+ * differentiated. Please see ISO 4217 for valid currency types.
+ *
  * Current options are:
  *  {
  *      languages: [
@@ -183,15 +187,15 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 //
                 // date
                 //
-                date: quote(
-                    textRawMF()
-                )
+                date: quote({
+                    type: "date"
+                })
                 //
                 // boolean
                 //
-                boolean: quote(
-                    textRawMF()
-                )
+                boolean: quote({
+                    type: "boolean"
+                })
                 //
                 // currency
                 //
@@ -213,15 +217,15 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 //
                 // integer
                 //
-                integer: quote(
-                    textRawMF()
-                )
+                integer: quote({
+                    type: "long"
+                })
                 //
                 // number
                 //
-                number: quote(
-                    textRawMF()
-                )
+                number: quote({
+                    type: "float"
+                })
                 //
                 // url
                 //
@@ -303,7 +307,6 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 properties: makeMapping(fields)
             }
         })
-        // printline("OpenSearchClient.create:\n${Dialect.print(params)}")
         prosc.request(indexName, {
             method: "PUT"
             putdata: params
@@ -500,7 +503,6 @@ closure OpenSearchClient(goptions, local oscl, prosc) {
             query.multi_match.fields = ["*"].concat(soptions.boost.fields.map(function (item) {
                 item.concat("^${soptions.boost.level}")
             }))
-        printline(Dialect.print(soptions.boost))
         if dictionary(soptions.qopts)
             query.multi_match = merge(query.multi_match, soptions.qopts)
         if dictionary(soptions.filter) {

package/plugins/serviceAws/aws_dynamo.nlg

@@ -357,7 +357,7 @@ closure DynaConverter(local conv) {
     //
     // condition dictionary:
     //  {
-    //      key:        <keyname, e.g. partition key name>                  // required
+    //      key:        <keyname, e.g. partition key name or path tuple>    // required
     //      "=":        <expression>                                        // exclusive of other comparisons
     //      ">":        <expression>                                        // exclusive of other comparisons
     //      "<":        <expression>                                        // exclusive of other comparisons
@@ -365,11 +365,12 @@ closure DynaConverter(local conv) {
     //      beginsWith: <string-expression>                                 // exclusive of other comparisons
     //      ">=":       <expression>                                        // with <= or alone
     //      "<=":       <expression>                                        // with >= or alone
+    //      exists:     <boolean>                                           // keyname existence matches boolean
     //  }
     //
 
     conv.createKeyExpression = function createKeyExpression(params, conds
-        local attval, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
+        local attval, attname, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
 
         // dupeop
         //
@@ -382,14 +383,24 @@ closure DynaConverter(local conv) {
         // build the expression
         //
         attval = genAttributeValueAdder(params)
+        attname = genAttributeNameAdder(params)
         for `(rangename, ranges) in conds {
             if !array(ranges)
                 ranges = [ranges]
             for range in ranges {
                 rangex = false
-                keyname = tostring(range.key)
+                if tuple(range.key) {
+                    keyname = []
+                    expr = range.key
+                    while expr
+                        keyname.push(attname(pop(expr)))
+                    keyname = keyname.join(".")
+                }
+                else
+                    keyname = tostring(range.key)
                 if !keyname
                     return (list(Error("key expression requires key name")))
+                keyname = attname(keyname)
                 for `(op, expr) in range {
                     if op == "key"
                         continue
@@ -417,10 +428,16 @@ closure DynaConverter(local conv) {
                     arg1 = rangex.1
                     if rangex.0 == "between" {
                         arg2 = rangex.2
-                        expr = keyname.concat(" between ", arg1, " and ", arg2)
+                        expr = "${keyname} between ${arg1} and ${arg2}"
                     }
                     else if rangex.0 == "beginsWith"
-                        expr = "begins_with(".concat(keyname, ", ", arg1, ")")
+                        expr = "begins_with(${keyname}, ${arg1})"
+                    else if rangex.0 == "exists" {
+                        if arg1
+                            expr = "attribute_exists(${keyname})"
+                        else
+                            expr = "attribute_not_exists(${keyname})"
+                    }
                     else
                         expr = keyname.concat(space, rangex.0, space, arg1)
                     if params[rangename]
@@ -674,14 +691,26 @@ closure DynaTable(dyna, tablename, local table) {
 
     // getRecord
     //
-    // Get a record from the table with the specified hash value, and optional range value.
+    // Get a record from the table with the specified hash value. The optional second argument can be
+    // the rangeValue of the item, or an options dictionary. Dictionary options include:
+    //  {
+    //      rangeValue:     <range-key>         // record's range key
+    //      consistentRead: <boolean>           // true to use consistent read
+    //  }
+    // The result is a standard result tuple `(error, record).
+
     //
-    table.getRecord = closure getRecord(hashValue, rangeValue, local params, pending) {
+    table.getRecord = closure getRecord(hashValue, options, local params, rangeValue, pending) {
         if preflightError(this)
             return
         params = {
             TableName: tablename
         }
+        if dictionary(options) {
+            rangeValue = options.rangeValue
+            params.ConsistentRead = options.consistentRead
+        } else
+            rangeValue = options
         params.Key = makeDynKey(list(hashValue, rangeValue))
         pending = new(nonce)
         dyna.aws.getItem(params, function(error, data) {
@@ -856,6 +885,7 @@ closure DynaTable(dyna, tablename, local table) {
     //      reverse:        <boolean>                                       // reverse order
     //      project:        <array>                                         // project only specified attributes
     //      paging:         <exclusive start key>                           // for paging; updated each call
+    //      consistentRead: <boolean>                                       // true to use consistent read
     //      limit:          <number>                                        // maximum count of results
     //  }
     //
@@ -902,6 +932,8 @@ closure DynaTable(dyna, tablename, local table) {
             params.ProjectionExpression = options.project.join(", ")
         if options.paging
             params.ExclusiveStartKey = options.paging
+        if options.consistentRead
+            params.ConsistentRead = options.consistentRead
         output = []
         `(error) = dynQueryPager(`query, params, options.limit, function(data) {
             if data.Count > 0
@@ -921,12 +953,13 @@ closure DynaTable(dyna, tablename, local table) {
     //
     // Options:
     //  {
-    //      index:      <string>                                            // index name in table
-    //      filter:     <key-expression>                                    // conditions for items to return
-    //      attmap:     <dictionary>                                        // map attribute names to #shortcuts
-    //      project:    <array>                                             // project only specified attributes
-    //      paging:     <exclusive start key>                               // for paging; updated each call
-    //      limit:      <number>                                            // maximum count of results
+    //      index:          <string>                                        // index name in table
+    //      filter:         <key-expression>                                // conditions for items to return
+    //      attmap:         <dictionary>                                    // map attribute names to #shortcuts
+    //      project:        <array>                                         // project only specified attributes
+    //      paging:         <exclusive start key>                           // for paging; updated each call
+    //      consistentRead: <boolean>                                       // true to use consistent read
+    //      limit:          <number>                                        // maximum count of results
     //  }
     //
 
@@ -953,6 +986,8 @@ closure DynaTable(dyna, tablename, local table) {
             params.ProjectionExpression = options.project.join(", ")
         if options.paging
             params.ExclusiveStartKey = options.paging
+        if options.consistentRead
+            params.ConsistentRead = options.consistentRead
         output = []
         `(error) = dynQueryPager(`scan, params, options.limit, function(data) {
             if data.Count >= 0

package/test/test_01_core.nlg

@@ -319,10 +319,13 @@ RegisterTestCategory("core", [
     [ "eval(`(+ 4 3));", "7" ],
     
     [ "apply(`+, `(4 3));", "7" ],
-    
+    [ "apply(getproc(`+), `(4, 3));", "7" ],                            // ensures that call takes a builtin as function
+    [ "apply(Number.parseInt, list('42'));", "42" ],
+
     [ "call(car(`+), 4, 3);", "7" ],
     [ "call(getproc(`+), 4, 3);", "7" ],                                // ensures that call takes a builtin as function
-    
+    [ "call(Number.parseInt, '42');", "42" ],
+
     [ "list();>", "false" ],
     [ "list(3, 4, 5, `(6 7));>", "(3 4 5 (6 7))" ],
 
@@ -354,12 +357,16 @@ RegisterTestCategory("core", [
     [ "print(testcore=`testcore);", "testcore|testcore" ],
     [ "print(testcore=42);", "42|42" ],
  
-    [ "cond();", { errors: "cond( requires if expression at (1, 6) found )" } ],
+    [ "cond();", "false" ],
+    [ "cond(true);",
+        { errors: "if expression required at (1, 6) found true" } ],
     [ "quote(cond(if false 3 else if true 4));>", "(cond ((identity false) 3) ((identity true) 4))" ],
     [ "cond(if false 3 else if true 4);", "4" ],
     [ "cond (if 1 and\n 2, 3);", "3" ],
     [ "cond(print(false),print(\"hi\"));",
-        { errors: "cond( requires if expression at (1, 6) found print" } ],
+        { errors: "if expression required at (1, 6) found print" } ],
+    [ "cond(if 3 4, print(5));",
+        { errors: "if expression required at (1, 14) found print" } ],
     
     [ "body();", "false" ],
     [ "quote(body(if false 3 else if true 4));>", "(body ((identity false) 3) ((identity true) 4))" ],
@@ -367,8 +374,10 @@ RegisterTestCategory("core", [
     [ "body(print(\"hi\"), print(\" there\"),4+3);>", "hi there|7" ],
     [ "body(print(false),print(\"hi\"));", "falsehi|\"hi\"" ],
 
-    [ "push();>", { errors: "attempt to modify constant false" } ],
-    [ "push(true);>", { errors: "attempt to modify constant false" } ],
+    [ "push();>",
+        { errors: "attempt to modify constant false" } ],
+    [ "push(true);>",
+        { errors: "attempt to modify constant false" } ],
     [ "push(true, 3);>", "false" ],
     [ "testcore=false;", "false" ],
     [ "push(11, testcore);>", "(11)" ],
@@ -424,7 +433,9 @@ RegisterTestCategory("core", [
     [ "temp(2, `(1 2 3));>", "(2 3)|(2 3)" ],
     [ "function (ex1, lex1) { ex1+pop(lex1), print(lex1), lex1 }(2, `(1 2 3));>", "(2 3)|(2 3)" ],
     [ "quote(function (a)\n { f(b)-\ng(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
-    [ "quote(function (a)\n { f(b)\n-g(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
+    [ "quote(function (a)\n { f(b)\n-g(c) * h(d)\n });>",
+        { errors: "ambiguous newline (use \\ or ,) at (3, 1) found -" }],
+    [ "quote(function (a)\n { f(b)\\\n-g(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
     
     [ "tempo = temp.proc;>", "(function temp (ex1 lex1) (+ ex1 (pop lex1)) (print lex1) lex1)" ],
     [ "function temp(ex1) { ex1 * 2 };", "==> redefined: temp|temp" ],
@@ -589,7 +600,21 @@ RegisterTestCategory("core", [
     [ "bobby.sue(44);", "(44)(sue billy)/Dictionary{2}|(sam nevil bill)/(sue billy)|(\"sue\", \"billy\")" ],
     [ "keys(bobby);>", "(\"sue\" \"billy\")" ],
     
-    
+    ["merge();", "{ }"],
+    ["merge({a:3});", "{ a: 3 }"],
+    ["merge({a:3,b:4});", "{ a: 3, b: 4 }"],
+    ["merge({a:3,b:4,c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge(`(a));", "{ }"],
+    ["merge({a:3}, `(a));", "{ }"],
+    ["merge({a:3,b:4}, `(a), {c:5});", "{ b: 4, c: 5 }"],
+    ["merge({a:3,b:4}, `(c), {c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge({a:3,b:4}, `(g), {c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge({true:a,false:b});", "{ true: a, false: a }"],
+    ["merge({true:a,false:b}, `(true));", "{ false: a }"],
+    ["oo={true:a}; oo[1.0/3]=`b; oo;", "{ true: a }|b|{ true: a, 0.3333333333333333: b }"],
+    ["merge(oo, list(1.0/3), {false:c});", "{ true: a, false: c }"],
+    ["oo;", "{ true: a, 0.3333333333333333: b }"],
+
     //
     // object getters
     //
@@ -796,6 +821,9 @@ RegisterTestCategory("core", [
     [ "cons(`a);>", "(a)" ],
     [ "cons(`a,`b);>", "(a . b)" ],
     [ "cons(`a,`b,`c);>", "(a b . c)" ],
+
+    [ "unintern(true) === true", "false"],
+
     [ "length(stacktrace());", "55" ],
     
     //

package/test/test_03_jsinterop.nlg

@@ -35,11 +35,11 @@ RegisterTestCategory("JSinterop", [
 
     [ "o(3);", {
         "dev": { errors: "xcall \"[object Object]\": TypeError: object.apply is not a function" }
-        "prod": { errors: "xcall \"[object Object]\": TypeError: e[3].apply is not a function" }
+        "prod": { errors: "xcall \"[object Object]\": TypeError: r[3].apply is not a function" }
     }[    "prod"]],
     [ "o(Number);", {
         "dev": { errors: "xcall \"[object Object]\": TypeError: object.apply is not a function" }
-        "prod": { errors: "xcall \"[object Object]\": TypeError: e[3].apply is not a function" }
+        "prod": { errors: "xcall \"[object Object]\": TypeError: r[3].apply is not a function" }
     }[    "prod"]],
     [ "Number(3);", "[Number 3]" ],
     [ "Number(3).toString();", "\"3\"" ],
@@ -63,6 +63,15 @@ RegisterTestCategory("JSinterop", [
 
     [ "xnew(js.g.Promise, function() {});", "[object Promise]" ],
     
+    //
+    // Arrays
+    //
+    
+    ["Array(3,4,5);", "[Array 3,4,5]"],
+    ["Array([3]);", "[Array [3]]"],
+    ["Array([3]).0;", "[Array 3]"],
+    ["Array([3]).0.0;", "3"],
+
     
     //
     // child processes

package/test/test_05_strings.nlg

@@ -71,6 +71,6 @@ RegisterTestCategory("strings", [
     [ "\"abc\".toString();", "\"abc\"" ],
     [ "xapply(String, toString, list(\"abc\"));", "\"abc\"" ],
     [ "xcall(String, toString, \"abc\");", "\"abc\"" ],
-    [ "function(local match) { \"abc\".match(RegExp(\"abc\")) }();", "[Array abc]" ]
+    [ "function(local match) { \"abc\".match(RegExp(\"abc\")) }();", '[Array "abc"]' ]
 
 ]);

package/test/test_06_lingoparse.nlg

@@ -438,15 +438,18 @@ RegisterTestCategory("Lingo parse", [
     [ "try{nest()}finally{};",
         { exprs: "(catch ((nest)) false false)" } ],
     [ "try{nest()}catch{}finally{};",
-        { exprs: "(catch ((nest)) (((identity true))) false)" } ],
+        { exprs: "(catch ((nest)) (((identity true) false)) false)" } ],
     [ "function test1() { try { nest() } finally { } };",
         { exprs: "(defproc function test1 false (catch ((nest)) false false))",
         text: "==> redefined: test1" } ],
     [ "function(){try{nest()}catch{},if(1)2};",
-        { exprs: "(function lambda false (catch ((nest)) (((identity true))) false) ((identity 1) 2))" } ],
+        { exprs: "(function lambda false (catch ((nest)) (((identity true) false)) false) ((identity 1) 2))" } ],
     [ "function(x) { try {} catch { if true { 4 } } };",
         { exprs: "(function lambda (x) (catch false (((identity true) 4)) false))" } ],
-    
+    [ "try { throw(green) } catch { printline(4) };",
+        { exprs: "(catch ((throw green)) (((identity true) (printline 4))) false)",
+        text: "4" } ],
+
     //
     // cond
     //
@@ -468,7 +471,7 @@ RegisterTestCategory("Lingo parse", [
     //
     
     [ "function() {test()[3]};>", "(function lambda false (deref (test) 3))"],
-    [ "function() {test()\n[3]};>", "(function lambda false (deref (test) 3))"],
+    [ "function() {test()\\\n[3]};>", "(function lambda false (deref (test) 3))"],
     [ "function() {test(),\n[3]};>", "(function lambda false (test) Array[1])"],
     [ "function() {test(),\n[3]};", "function () {\n"
         "    test(),\n"                                                     // need comma before array
@@ -497,6 +500,42 @@ RegisterTestCategory("Lingo parse", [
         "    else {\n"
         "        { a: 3 } }\n"                                              // need braces around dictionary
         "}" ],
+    [ "function() {if 1, -2 };", "function () {\n"
+        "    if 1\n"
+        "        -2\n"
+        "}" ],
+    [ "function() {if 1,\n"
+                    "-2 };", "function () {\n"
+        "    if 1\n"
+        "        -2\n"
+        "}" ],
+    [ "function() {if 1\n"
+                    "-2 };",
+        { errors: "ambiguous newline (use \\ or ,) at (2, 1) found -" } ],
+    [ "function() {if 1\\\n"
+                    "-2 3 };", "function () {\n"
+        "    if 1 - 2\n"
+        "        3\n"
+        "}" ],
+    [ "function(x) {if x\n[2]\n3 };",
+        { errors: "ambiguous newline (use \\ or ,) at (2, 1) found [" } ],
+    [ "function(x) {if x,\n[2]\n3 };",
+        "function (x) {\n"
+        "    if x\n"
+        "        [2]\n"
+        "    3\n"
+        "}" ],
+    [ "function(x) {if x\\\n[2]\n3 };",
+        "function (x) {\n"
+        "    if x[2]\n"
+        "        3\n"
+        "}" ],
+    [ "function(x) {if x\n(2)\n3 };",
+        { errors: "ambiguous newline (use \\ or ,) at (2, 1) found (" } ],
+    [ "function() { else };",
+        { errors: "stray keyword at (1, 14) found else" } ],
+    [ "function() { if 1 else 3 };",
+        { errors: "stray keyword at (1, 19) found else" } ],
 
     //
     // semantic validity

package/test/test_07_lingo.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2018-2021 by Richard C. Zulch
+ * Copyright (c) 2018-2023 by Richard C. Zulch
  *
  */
 
@@ -159,15 +159,25 @@ RegisterTestCategory("Lingo", [
 //      "        map           : [(0, 23), 0, 9, 2, 7],\n" -- maps currently omitted
         "        comments      : [] } }" ],
     [ "testat@jim(true);", "\"you are annotated with true!\"" ],
+    [ "copyann(testat, a);", "testat" ],
+    [ "testat@*;", '("joe", "jim", ".sourcemap")' ],
+    [ "copyann(testat, a, true);", "testat" ],
+    [ "testat@*;", '("joe")' ],
+    [ "copyann(3, a);", { errors: "attempt to modify constant 3" } ],
+    [ "copyann(a, 3);", "false" ],
 
 
     //
-    // lists, objects & arrays
+    // lists, dictionaries, objects, and arrays
     //
     
     [ "divide(71, 3);", "(23 . 2)" ],
     [ "[3,4+5];", "[3, 9]" ],
     [ "{a:3,b:4+5};", "{ a: 3, b: 9 }" ],
+    [ "function(g) { { a: 3+g } }(5);", "{ a: 8 }" ],
+    [ "function(g) { { a: false || undefined } }(6);", "{ }" ],
+    [ "function(g) { { a: false && g || undefined } }(7);", "{ }" ],
+    [ "function(g) { { a: true && g || undefined } }(8);", "{ a: 8 }" ],
 
     [ "`(1, 2, {a:3,b:4}, 5);", "(1, 2, { a: 3, b: 4 }, 5)" ],
     [ "`(1, 2, {a:3,b:4}, 5);>", "(1 2 Dictionary{2} 5)" ],
@@ -287,6 +297,27 @@ RegisterTestCategory("Lingo", [
     [ "aa[1] /= 2;", "3" ],
 
 
+    //
+    // catch
+    //
+    
+    [ "try { throw(green) } catch { printline(4) };", "4|4" ],
+    [ "try { throw(blue) } catch { false(),printline(5) };", "5|5" ],
+    [ "try { 1/0 } catch {};", "false"],
+    [ "try { 1/0 } catch { 0 };", "0"],
+    [ "try { 1/0 } catch { exception };", '(internal, "divide by zero")'],
+    [ "try { 1/0 } catch { if exception == 3 4, printline(5) };",
+        { errors: "if expression required at (1, 42) found printline"} ],
+    [ "try { throw(blue) } catch { if exception == blue printline(blue) };", "blue|blue"],
+    [ "try { throw(green) } catch { if exception == blue printline(blue) };", 
+        { errors: "exception: green" } ],
+    [ "try { throw(green) } catch { if exception == blue printline(blue),"
+        "if exception == green printline(green) };", "green|green"],
+    [ "try { throw(red) } catch { if exception == blue printline(blue),"
+        "if exception == green printline(green) };", 
+        { errors: "exception: red" } ],
+
+
     //
     // if else
     //