Further improvements and optimizations (some carried over from the precision work)

Author: TotalTechGeek

async_optimizer.js

@@ -28,7 +28,7 @@ function getMethod (logic, engine, methodName, above) {
   }
 
   let args = logic[methodName]
-  if (!args || typeof args !== 'object') args = [args]
+  if ((!args || typeof args !== 'object') && !method.optimizeUnary) args = [args]
 
   if (Array.isArray(args)) {
     const optimizedArgs = args.map(l => optimize(l, engine, above))
@@ -50,12 +50,12 @@ function getMethod (logic, engine, methodName, above) {
 
     if (isSync(optimizedArgs) && (method.method || method[Sync])) {
       const called = method.method ? method.method : method
-      return declareSync((data, abv) => called(coerceArray(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs, method.optimizeUnary), data, abv || above, engine), true)
+      if (method.optimizeUnary) return declareSync((data, abv) => called(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine.fallback), true)
+      return declareSync((data, abv) => called(coerceArray(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs), data, abv || above, engine), true)
     }
 
-    return async (data, abv) => {
-      return called(coerceArray(typeof optimizedArgs === 'function' ? await optimizedArgs(data, abv) : optimizedArgs, method.optimizeUnary), data, abv || above, engine)
-    }
+    if (method.optimizeUnary) return async (data, abv) => called(typeof optimizedArgs === 'function' ? await optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine)
+    return async (data, abv) => called(coerceArray(typeof optimizedArgs === 'function' ? await optimizedArgs(data, abv) : optimizedArgs), data, abv || above, engine)
   }
 }
 

compatibility.js

@@ -1,7 +1,9 @@
+import { Sync } from './constants.js'
 import defaultMethods from './defaultMethods.js'
 const oldAll = defaultMethods.all
 
 const all = {
+  [Sync]: oldAll[Sync],
   method: (args, context, above, engine) => {
     if (Array.isArray(args)) {
       const first = engine.run(args[0], context, above)

defaultMethods.js

@@ -212,6 +212,7 @@ const defaultMethods = {
   // Why "executeInLoop"? Because if it needs to execute to get an array, I do not want to execute the arguments,
   // Both for performance and safety reasons.
   '??': {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, _1, _2, engine) => {
       // See "executeInLoop" above
       const executeInLoop = Array.isArray(arr)
@@ -249,6 +250,7 @@ const defaultMethods = {
     traverse: false
   },
   or: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, _1, _2, engine) => {
       // See "executeInLoop" above
       const executeInLoop = Array.isArray(arr)
@@ -284,6 +286,7 @@ const defaultMethods = {
     traverse: false
   },
   and: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, _1, _2, engine) => {
       // See "executeInLoop" above
       const executeInLoop = Array.isArray(arr)
@@ -419,6 +422,7 @@ const defaultMethods = {
   some: createArrayIterativeMethod('some', true),
   all: createArrayIterativeMethod('every', true),
   none: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     traverse: false,
     // todo: add async build & build
     method: (val, context, above, engine) => {
@@ -439,7 +443,7 @@ const defaultMethods = {
   },
   merge: (arrays) => (Array.isArray(arrays) ? [].concat(...arrays) : [arrays]),
   every: createArrayIterativeMethod('every'),
-  filter: createArrayIterativeMethod('filter'),
+  filter: createArrayIterativeMethod('filter', true),
   reduce: {
     deterministic: (data, buildState) => {
       return (
@@ -548,11 +552,27 @@ const defaultMethods = {
   },
   '!': (value, _1, _2, engine) => Array.isArray(value) ? !engine.truthy(value[0]) : !engine.truthy(value),
   '!!': (value, _1, _2, engine) => Boolean(Array.isArray(value) ? engine.truthy(value[0]) : engine.truthy(value)),
-  cat: (arr) => {
-    if (typeof arr === 'string') return arr
-    let res = ''
-    for (let i = 0; i < arr.length; i++) res += arr[i]
-    return res
+  cat: {
+    [OriginalImpl]: true,
+    [Sync]: true,
+    method: (arr) => {
+      if (typeof arr === 'string') return arr
+      if (!Array.isArray(arr)) return arr.toString()
+      let res = ''
+      for (let i = 0; i < arr.length; i++) res += arr[i].toString()
+      return res
+    },
+    deterministic: true,
+    traverse: true,
+    optimizeUnary: true,
+    compile: (data, buildState) => {
+      if (typeof data === 'string') return JSON.stringify(data)
+      if (typeof data === 'number') return '"' + JSON.stringify(data) + '"'
+      if (!Array.isArray(data)) return false
+      let res = buildState.compile`''`
+      for (let i = 0; i < data.length; i++) res = buildState.compile`${res} + ${data[i]}`
+      return buildState.compile`(${res})`
+    }
   },
   keys: ([obj]) => typeof obj === 'object' ? Object.keys(obj) : [],
   pipe: {
@@ -673,8 +693,8 @@ function createArrayIterativeMethod (name, useTruthy = false) {
         (await engine.run(selector, context, {
           above
         })) || []
-      return asyncIterators[name](selector, (i, index) => {
-        const result = engine.run(mapper, i, {
+      return asyncIterators[name](selector, async (i, index) => {
+        const result = await engine.run(mapper, i, {
           above: [{ iterator: selector, index }, context, above]
         })
         return useTruthy ? engine.truthy(result) : result
@@ -694,15 +714,16 @@ function createArrayIterativeMethod (name, useTruthy = false) {
 
       const method = build(mapper, mapState)
       const aboveArray = method.aboveDetected ? buildState.compile`[{ iterator: z, index: x }, context, above]` : buildState.compile`null`
+      const useTruthyMethod = useTruthy ? buildState.compile`engine.truthy` : buildState.compile``
 
       if (async) {
         if (!isSync(method)) {
           buildState.asyncDetected = true
-          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x, z) => ${method}(i, x, ${aboveArray}))`
+          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x, z) => ${useTruthyMethod}(${method}(i, x, ${aboveArray})))`
         }
       }
 
-      return buildState.compile`(${selector} || [])[${name}]((i, x, z) => ${method}(i, x, ${aboveArray}))`
+      return buildState.compile`(${selector} || [])[${name}]((i, x, z) => ${useTruthyMethod}(${method}(i, x, ${aboveArray})))`
     },
     traverse: false
   }

optimizer.js

@@ -20,7 +20,7 @@ function getMethod (logic, engine, methodName, above) {
   }
 
   let args = logic[methodName]
-  if (!args || typeof args !== 'object') args = [args]
+  if ((!args || typeof args !== 'object') && !method.optimizeUnary) args = [args]
 
   if (Array.isArray(args)) {
     const optimizedArgs = args.map(l => optimize(l, engine, above))
@@ -30,9 +30,8 @@ function getMethod (logic, engine, methodName, above) {
     }
   } else {
     const optimizedArgs = optimize(args, engine, above)
-    return (data, abv) => {
-      return called(coerceArray(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs, method.optimizeUnary), data, abv || above, engine)
-    }
+    if (method.optimizeUnary) return (data, abv) => called(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine)
+    return (data, abv) => called(coerceArray(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs), data, abv || above, engine)
   }
 }