Disable object accumulators by default; still trying to figure out how I

want to handle the max length thing efficiently...

Author: TotalTechGeek

asyncLogic.js

@@ -23,15 +23,15 @@ class AsyncLogicEngine {
    * - In mainline: empty arrays are falsey; in our implementation, they are truthy.
    *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: boolean, permissive?: boolean }} options
+   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: boolean, permissive?: boolean, enableObjectAccumulators?: boolean, maxArrayLength?: number, maxStringLength?: number }} options
    */
   constructor (
     methods = defaultMethods,
-    options = { disableInline: false, disableInterpretedOptimization: false, permissive: false }
+    options = { disableInline: false, disableInterpretedOptimization: false, permissive: false, enableObjectAccumulators: false, maxArrayLength: 1 << 15, maxStringLength: 1 << 16 }
   ) {
     this.methods = { ...methods }
-    /** @type {{disableInline?: Boolean, disableInterpretedOptimization?: Boolean }} */
-    this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization }
+    /** @type {{disableInline?: Boolean, disableInterpretedOptimization?: Boolean, enableObjectAccumulators?: Boolean, maxArrayLength?: number, maxStringLength?: number}} */
+    this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization, enableObjectAccumulators: options.enableObjectAccumulators || false, maxArrayLength: options.maxArrayLength || (1 << 15), maxStringLength: options.maxStringLength || (1 << 16) }
     this.disableInline = options.disableInline
     this.disableInterpretedOptimization = options.disableInterpretedOptimization
     this.async = true

async_iterators.js

@@ -1,5 +1,8 @@
 // @ts-check
 'use strict'
+
+import { assertNotType } from './utilities/downgrade.js'
+
 // Note: Each of these iterators executes synchronously, and will not "run in parallel"
 // I am supporting filter, reduce, some, every, map
 export async function filter (arr, iter) {
@@ -36,19 +39,17 @@ export async function map (arr, iter) {
   return result
 }
 
-export async function reduce (arr, iter, defaultValue) {
+export async function reduce (arr, iter, defaultValue, skipTypeCheck = false) {
   if (arr.length === 0) {
-    if (typeof defaultValue !== 'undefined') {
-      return defaultValue
-    }
+    if (typeof defaultValue !== 'undefined') return defaultValue
     throw new Error('Array has no elements.')
   }
 
   const start = typeof defaultValue === 'undefined' ? 1 : 0
-  let data = start ? arr[0] : defaultValue
+  let data = assertNotType(start ? arr[0] : defaultValue, skipTypeCheck ? '' : 'object')
 
   for (let i = start; i < arr.length; i++) {
-    data = await iter(data, arr[i])
+    data = assertNotType(await iter(data, arr[i]), skipTypeCheck ? '' : 'object')
   }
 
   return data

compiler.js

@@ -11,7 +11,7 @@ import {
 import asyncIterators from './async_iterators.js'
 import { coerceArray } from './utilities/coerceArray.js'
 import { countArguments } from './utilities/countArguments.js'
-import { precoerceNumber, assertSize, compareCheck } from './utilities/downgrade.js'
+import { precoerceNumber, assertSize, compareCheck, assertNotType } from './utilities/downgrade.js'
 
 /**
  * Provides a simple way to compile logic into a function that can be run.
@@ -319,12 +319,12 @@ function processBuiltString (method, str, buildState) {
     str = str.replace(`__%%%${x}%%%__`, item)
   })
 
-  const final = `(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck) => ${buildState.asyncDetected ? 'async' : ''} (context ${buildState.extraArguments ? ',' + buildState.extraArguments : ''}) => { ${str.includes('prev') ? 'let prev;' : ''} const result = ${str}; return result }`
+  const final = `(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck, assertNotType) => ${buildState.asyncDetected ? 'async' : ''} (context ${buildState.extraArguments ? ',' + buildState.extraArguments : ''}) => { ${str.includes('prev') ? 'let prev;' : ''} const result = ${str}; return result }`
   // console.log(str)
   // console.log(final)
   // eslint-disable-next-line no-eval
   return Object.assign(
-    (typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck), {
+    (typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck, assertNotType), {
       [Sync]: !buildState.asyncDetected,
       deterministic: !str.includes('('),
       aboveDetected: typeof str === 'string' && str.includes(', above')

defaultMethods.js

@@ -7,7 +7,7 @@ import declareSync from './utilities/declareSync.js'
 import { build, buildString } from './compiler.js'
 import chainingSupported from './utilities/chainingSupported.js'
 import legacyMethods from './legacy.js'
-import { precoerceNumber } from './utilities/downgrade.js'
+import { precoerceNumber, assertNotType } from './utilities/downgrade.js'
 
 const INVALID_ARGUMENTS = { type: 'Invalid Arguments' }
 
@@ -32,7 +32,7 @@ function isDeterministic (method, engine, buildState) {
     return typeof engine.methods[func].deterministic === 'function'
       ? engine.methods[func].deterministic(lower, buildState)
       : engine.methods[func].deterministic &&
-          isDeterministic(lower, engine, buildState)
+      isDeterministic(lower, engine, buildState)
   }
   return true
 }
@@ -315,9 +315,9 @@ const defaultMethods = {
       if (Array.isArray(data) && data.length) {
         return `(${data.map((i, x) => {
           const built = buildString(i, buildState)
-        if (Array.isArray(i) || !i || typeof i !== 'object' || x === data.length - 1) return built
-        return '(' + built + ')'
-      }).join(' ?? ')})`
+          if (Array.isArray(i) || !i || typeof i !== 'object' || x === data.length - 1) return built
+          return '(' + built + ')'
+        }).join(' ?? ')})`
       }
       return `(${buildString(data, buildState)}).reduce((a,b) => (a) ?? b, null)`
     },
@@ -653,40 +653,37 @@ const defaultMethods = {
       }
       mapper = build(mapper, mapState)
       const aboveArray = mapper.aboveDetected ? '[null, context, above]' : 'null'
-
+      const verifyAccumulator = buildState.engine.options.enableObjectAccumulators ? '' : 'assertNotType'
       buildState.methods.push(mapper)
+
       if (async) {
         if (!isSync(mapper) || selector.includes('await')) {
           buildState.asyncDetected = true
           if (typeof defaultValue !== 'undefined') {
-            return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${
-              buildState.methods.length - 1
-            }]({ accumulator: a, current: b }, ${aboveArray}), ${defaultValue})`
+            return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${buildState.methods.length - 1}]({ accumulator: a, current: b }, ${aboveArray}), ${defaultValue}, ${buildState.engine.options.enableObjectAccumulators})`
           }
-          return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${
-            buildState.methods.length - 1
-          }]({ accumulator: a, current: b }, ${aboveArray}))`
+          return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${buildState.methods.length - 1}]({ accumulator: a, current: b }, ${aboveArray}), undefined, ${buildState.engine.options.enableObjectAccumulators})`
         }
       }
+
       if (typeof defaultValue !== 'undefined') {
-        return `(${selector} || []).reduce((a,b) => methods[${
-          buildState.methods.length - 1
-        }]({ accumulator: a, current: b }, ${aboveArray}), ${defaultValue})`
+        return `(${selector} || []).reduce((a,b) => ${verifyAccumulator}(methods[${buildState.methods.length - 1}]({ accumulator: a, current: b }, ${aboveArray})), ${verifyAccumulator}(${defaultValue}))`
       }
-      return `(${selector} || []).reduce((a,b) => methods[${
-        buildState.methods.length - 1
-      }]({ accumulator: a, current: b }, ${aboveArray}))`
+      return `(${selector} || []).reduce((a,b) => ${verifyAccumulator}(methods[${buildState.methods.length - 1}]({ accumulator: a, current: b }, ${aboveArray})))`
     },
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw INVALID_ARGUMENTS
       let [selector, mapper, defaultValue] = input
-      defaultValue = runOptimizedOrFallback(defaultValue, engine, context, above)
+
+      const verifyAccumulator = engine.options.enableObjectAccumulators ? a => a : assertNotType
+
+      defaultValue = verifyAccumulator(runOptimizedOrFallback(defaultValue, engine, context, above))
       selector = runOptimizedOrFallback(selector, engine, context, above) || []
-      let func = (accumulator, current) => engine.run(mapper, { accumulator, current }, { above: [selector, context, above] })
+      let func = (accumulator, current) => verifyAccumulator(engine.run(mapper, { accumulator, current }, { above: [selector, context, above] }), 'object')
 
       if (engine.optimizedMap.has(mapper) && typeof engine.optimizedMap.get(mapper) === 'function') {
         const optimized = engine.optimizedMap.get(mapper)
-        func = (accumulator, current) => optimized({ accumulator, current }, [selector, context, above])
+        func = (accumulator, current) => verifyAccumulator(optimized({ accumulator, current }, [selector, context, above]))
       }
 
       if (typeof defaultValue === 'undefined') return selector.reduce(func)
@@ -697,13 +694,10 @@ const defaultMethods = {
     asyncMethod: async (input, context, above, engine) => {
       if (!Array.isArray(input)) throw INVALID_ARGUMENTS
       let [selector, mapper, defaultValue] = input
-      defaultValue = await engine.run(defaultValue, context, {
-        above
-      })
-      selector =
-        (await engine.run(selector, context, {
-          above
-        })) || []
+      const verifyAccumulator = engine.options.enableObjectAccumulators ? a => a : assertNotType
+
+      defaultValue = verifyAccumulator(await engine.run(defaultValue, context, { above }))
+      selector = (await engine.run(selector, context, { above })) || []
       return asyncIterators.reduce(
         selector,
         (accumulator, current) => {
@@ -718,7 +712,8 @@ const defaultMethods = {
             }
           )
         },
-        defaultValue
+        defaultValue,
+        engine.enableObjectAccumulators
       )
     },
     lazy: true
@@ -827,7 +822,8 @@ const defaultMethods = {
           })
           return accumulator
         },
-        {}
+        {},
+        true
       )
       return result
     }
@@ -1058,11 +1054,11 @@ defaultMethods['/'].compile = function (data, buildState) {
     if (data.length === 0) throw INVALID_ARGUMENTS
     if (data.length === 1) data = [1, data[0]]
     return `precoerceNumber(${data.map((i, x) => {
-    let res = numberCoercion(i, buildState)
-    if (x && res === '+0') precoerceNumber(NaN)
-    if (x) res = `precoerceNumber(${res} || NaN)`
-    return res
-  }).join(' / ')})`
+      let res = numberCoercion(i, buildState)
+      if (x && res === '+0') precoerceNumber(NaN)
+      if (x) res = `precoerceNumber(${res} || NaN)`
+      return res
+    }).join(' / ')})`
   }
   return `assertSize(prev = ${buildString(data, buildState)}, 1) && prev.length === 1 ? 1 / precoerceNumber(prev[0] || NaN) : prev.reduce((a,b) => (+precoerceNumber(a))/(+precoerceNumber(b || NaN)))`
 }

logic.js

@@ -18,11 +18,11 @@ class LogicEngine {
    * Creates a new instance of the Logic Engine.
   *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean, permissive?: boolean }} options
+   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean, permissive?: boolean, enableObjectAccumulators?: boolean, maxArrayLength?: number, maxStringLength?: number }} options
    */
   constructor (
     methods = defaultMethods,
-    options = { disableInline: false, disableInterpretedOptimization: false, permissive: false }
+    options = { disableInline: false, disableInterpretedOptimization: false, permissive: false, enableObjectAccumulators: false, maxArrayLength: 1 << 15, maxStringLength: 1 << 16 }
   ) {
     this.disableInline = options.disableInline
     this.disableInterpretedOptimization = options.disableInterpretedOptimization
@@ -31,8 +31,8 @@ class LogicEngine {
     this.optimizedMap = new WeakMap()
     this.missesSinceSeen = 0
 
-    /** @type {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean }} */
-    this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization }
+    /** @type {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean, enableObjectAccumulators?: boolean, maxArrayLength?: number, maxStringLength?: number }} */
+    this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization, enableObjectAccumulators: options.enableObjectAccumulators || false, maxArrayLength: options.maxArrayLength || (1 << 15), maxStringLength: options.maxStringLength || (1 << 16) }
     if (!this.isData) {
       if (!options.permissive) this.isData = () => false
       else this.isData = (data, key) => !(key in this.methods)

suites/additional.json

@@ -76,5 +76,29 @@
         "rule": { "val": { "cat": ["te", "st"] } },
         "data": { "test": 1 },
         "result": 1
+    },
+    {
+      "description": "Throws when you try to use reduce with an array as the accumulator (Default)",
+      "rule": { "reduce": [[1,2,3], 0, []] },
+      "error": { "type": "Invalid Return" },
+      "data": null
+    },
+    {
+      "description": "Throws when you try to use reduce with an array as the accumulator (Return)",
+      "rule": { "reduce": [[1,2,3], []] },
+      "error": { "type": "Invalid Return" },
+      "data": null
+    },
+    {
+      "description": "Throws when you try to use reduce with an object as the accumulator (Default)",
+      "rule": { "reduce": [[1,2,3], 0, {}] },
+      "error": { "type": "Invalid Return" },
+      "data": null
+    },
+    {
+      "description": "Throws when you try to use reduce with an object as the accumulator (Return)",
+      "rule": { "reduce": [[1,2,3], {}] },
+      "error": { "type": "Invalid Return" },
+      "data": null
     }
-]
+]

utilities/downgrade.js

@@ -20,6 +20,20 @@ export function assertSize (arr, size) {
   return arr
 }
 
+/**
+ * Asserts that an item is not of a certain type.
+ * Treats null as its own type, "null".
+ * The main use-case for this is to prevent reduce from returning objects.
+ * @param {*} item
+ * @param {string} type
+ */
+export function assertNotType (item, type = 'object', error = 'Invalid Return') {
+  const typeOfItem = item === null ? 'null' : typeof item
+  // eslint-disable-next-line no-throw-literal
+  if (typeOfItem === type) throw { type: error }
+  return item
+}
+
 /**
  * Used to assert in compiled templates that when a numeric comparison is made, both values are numbers.
  * @param {*} item