Experimenting with Soft Errors

Author: TotalTechGeek

compatibility.js

@@ -24,6 +24,7 @@ const all = {
 
 function truthy (value) {
   if (Array.isArray(value) && value.length === 0) return false
+  if (Number.isNaN(value)) return true
   return value
 }
 

compatible.test.js

@@ -16,6 +16,7 @@ for (const file of files) {
 function correction (x) {
   // eslint-disable-next-line no-compare-neg-zero
   if (x === -0) return 0
+  if (Number.isNaN(x)) return { error: 'NaN' }
   return x
 }
 

defaultMethods.js

@@ -56,8 +56,12 @@ const defaultMethods = {
     if (typeof data === 'string') return +data
     if (typeof data === 'number') return +data
     if (typeof data === 'boolean') return +data
+    if (typeof data === 'object' && !Array.isArray(data)) return Number.NaN
     let res = 0
-    for (let i = 0; i < data.length; i++) res += +data[i]
+    for (let i = 0; i < data.length; i++) {
+      if (data[i] && typeof data[i] === 'object') return Number.NaN
+      res += +data[i]
+    }
     return res
   },
   '*': (data) => {
@@ -85,6 +89,11 @@ const defaultMethods = {
     for (let i = 1; i < data.length; i++) res %= +data[i]
     return res
   },
+  error: (type) => {
+    if (Array.isArray(type)) type = type[0]
+    if (type === 'NaN') return Number.NaN
+    return { error: type }
+  },
   max: (data) => Math.max(...data),
   min: (data) => Math.min(...data),
   in: ([item, array]) => (array || []).includes(item),
@@ -855,9 +864,14 @@ defaultMethods['==='].compile = function (data, buildState) {
 defaultMethods['+'].compile = function (data, buildState) {
   if (Array.isArray(data)) {
     return `(${data
-      .map((i) => `(+${buildString(i, buildState)})`)
+      .map((i) => {
+        // Todo: Actually make this correct, this is a decent optimization but
+        // does not coerce the built string.
+        if (Array.isArray(i)) return 'NaN'
+        return `(+${buildString(i, buildState)})`
+      })
       .join(' + ')})`
-  } else if (typeof data === 'string' || typeof data === 'number') {
+  } else if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') {
     return `(+${buildString(data, buildState)})`
   } else {
     return `([].concat(${buildString(
@@ -943,12 +957,12 @@ defaultMethods.not = defaultMethods['!']
 // @ts-ignore Allow custom attribute
 defaultMethods['!!'].compile = function (data, buildState) {
   if (Array.isArray(data)) return buildState.compile`(!!engine.truthy(${data[0]}))`
-  return `(!!engine.truthy(${data}))`
+  return buildState.compile`(!!engine.truthy(${data}))`
 }
 defaultMethods.none.deterministic = defaultMethods.some.deterministic
 
 // @ts-ignore Allowing a optimizeUnary attribute that can be used for performance optimizations
-defaultMethods['+'].optimizeUnary = defaultMethods['-'].optimizeUnary = defaultMethods['!'].optimizeUnary = defaultMethods['!!'].optimizeUnary = defaultMethods.cat.optimizeUnary = true
+defaultMethods['+'].optimizeUnary = defaultMethods['-'].optimizeUnary = defaultMethods['!'].optimizeUnary = defaultMethods['!!'].optimizeUnary = defaultMethods.cat.optimizeUnary = defaultMethods.error.optimizeUnary = true
 
 export default {
   ...defaultMethods,

suites/divide.json

@@ -146,5 +146,23 @@
         "rule": { "/": [{ "val": "x" }, { "val": "y" }] },
         "data": { "x": 8, "y": 2 },
         "result": 4
+    },
+    {
+        "description": "Divide by Zero",
+        "rule": { "/": [0, 0] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Divide by NaN",
+        "rule": { "/": [1, { "error": "NaN" }] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Divide with String produces NaN",
+        "rule": { "/": [1, "a"] },
+        "result": { "error": "NaN" },
+        "data": null
     }
 ]

suites/errors.json

@@ -0,0 +1,15 @@
+[
+    "# Some error tests",
+    {
+        "description": "NaN is Truthy",
+        "rule": { "!!": { "error": "NaN" } },
+        "result": true,
+        "data": null
+    },
+    {
+        "description": "Arbitrary error is Truthy",
+        "rule": { "!!": { "error": "Some error" } },
+        "result": true,
+        "data": null
+    }
+]

suites/minus.json

@@ -114,5 +114,17 @@
         "rule": { "-": [{ "val": "x" }, { "val": "y" }] },
         "data": { "x": 1, "y": 2 },
         "result": -1
+    },
+    {
+        "description": "Subtraction with NaN",
+        "rule": { "-": [{ "error": "NaN" }, 1] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Subtraction with string produces NaN",
+        "rule": { "-": ["Hey", 1] },
+        "result": { "error": "NaN" },
+        "data": null
     }
 ]

suites/modulo.json

@@ -157,5 +157,17 @@
         "rule": { "%": [{ "val": "x" }, { "val": "y" }] },
         "data": { "x": 11, "y": 6 },
         "result": 5
+    },
+    {
+        "description": "Modulo with NaN",
+        "rule": { "%": [{ "error": "NaN" }, 1] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Modulo with string produces NaN",
+        "rule": { "%": ["Hey", 1] },
+        "result": { "error": "NaN" },
+        "data": null
     }
 ]

suites/multiply.json

@@ -144,5 +144,17 @@
         "rule": { "*": [{ "val": "x" }, { "val": "y" }] },
         "data": { "x": 8, "y": 2 },
         "result": 16
+    },
+    {
+        "description": "Multiply with NaN",
+        "rule": { "*": [{ "error": "NaN" }, 1] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Multiply with string produces NaN",
+        "rule": { "*": ["Hey", 1] },
+        "result": { "error": "NaN" },
+        "data": null
     }
 ]

suites/plus.json

@@ -138,7 +138,25 @@
     {
         "description": "Addition with val",
         "rule": { "+": [{ "val": "x" }, { "val": "y" }] },
-        "data": { "x": 1, "y": 2 },
-        "result": 3
+        "result": 3,
+        "data": { "x": 1, "y": 2 }
+    },
+    {
+        "description": "Addition with NaN",
+        "rule": { "+": [{ "error": "NaN" }, 1] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Addition with string produces NaN",
+        "rule": { "+": ["Hey", 1] },
+        "result": { "error": "NaN" },
+        "data": null
+    },
+    {
+        "description": "Addition with Array produces NaN",
+        "rule": { "+": [[1], 1] },
+        "result": { "error": "NaN" },
+        "data": null
     }
 ]