chore: put evaluation in the apply call

jitsedesmet · Oct 23, 2023 · a5a9cfd · a5a9cfd
1 parent 262692e
commit a5a9cfd
Show file tree

Hide file tree

Showing 8 changed files with 29 additions and 31 deletions.
diff --git a/packages/actor-bindings-aggregator-factory-average/lib/AverageAggregator.ts b/packages/actor-bindings-aggregator-factory-average/lib/AverageAggregator.ts
@@ -33,7 +33,7 @@ export class AverageAggregator extends AggregateEvaluator implements IBindingsAg
       this.state = { sum, count: 1 };
     } else {
       const internalTerm = this.termToNumericOrError(term);
-      this.state.sum = <E.NumericLiteral> this.summer.syncApply([ this.state.sum, internalTerm ],
+      this.state.sum = <E.NumericLiteral> this.summer.applyOnTerms([ this.state.sum, internalTerm ],
         <ExpressionEvaluator> this.evaluator);
       this.state.count++;
     }
@@ -44,7 +44,7 @@ export class AverageAggregator extends AggregateEvaluator implements IBindingsAg
       return this.emptyValue();
     }
     const count = new E.IntegerLiteral(this.state.count);
-    const result = this.divider.syncApply([ this.state.sum, count ], <ExpressionEvaluator> this.evaluator);
+    const result = this.divider.applyOnTerms([ this.state.sum, count ], <ExpressionEvaluator> this.evaluator);
     return result.toRDF();
   }
 }
diff --git a/packages/actor-bindings-aggregator-factory-sum/lib/SumAggregator.ts b/packages/actor-bindings-aggregator-factory-sum/lib/SumAggregator.ts
@@ -27,7 +27,7 @@ export class SumAggregator extends AggregateEvaluator {
       this.state = this.termToNumericOrError(term);
     } else {
       const internalTerm = this.termToNumericOrError(term);
-      this.state = <E.NumericLiteral> this.summer.syncApply([ this.state, internalTerm ],
+      this.state = <E.NumericLiteral> this.summer.applyOnTerms([ this.state, internalTerm ],
         <ExpressionEvaluator> this.evaluator);
     }
   }

diff --git a/packages/expression-evaluator/lib/evaluators/ExpressionEvaluator.ts b/packages/expression-evaluator/lib/evaluators/ExpressionEvaluator.ts
@@ -161,10 +161,10 @@ export class ExpressionEvaluator implements IExpressionEvaluator {
     const myLitB = termTransformer.transformLiteral(litB);
 
     try {
-      if ((<E.BooleanLiteral> isEqual.syncApply([ myLitA, myLitB ], this)).typedValue) {
+      if ((<E.BooleanLiteral> isEqual.applyOnTerms([ myLitA, myLitB ], this)).typedValue) {
         return 0;
       }
-      if ((<E.BooleanLiteral> isGreater.syncApply([ myLitA, myLitB ], this)).typedValue) {
+      if ((<E.BooleanLiteral> isGreater.applyOnTerms([ myLitA, myLitB ], this)).typedValue) {
         return 1;
       }
       return -1;

diff --git a/packages/expression-evaluator/lib/evaluators/evaluatorHelpers/AsyncRecursiveEvaluator.ts b/packages/expression-evaluator/lib/evaluators/evaluatorHelpers/AsyncRecursiveEvaluator.ts
@@ -70,7 +70,7 @@ export class AsyncRecursiveEvaluator {
 
   private async evalOperator(expr: E.Operator, mapping: RDF.Bindings): Promise<E.Term> {
     const context: IEvalContext = {
-      args: await Promise.all(expr.args.map(arg => this.evaluate(arg, mapping))),
+      args: expr.args,
       mapping,
       exprEval: this.expressionEvaluator,
 
@@ -90,15 +90,10 @@ export class AsyncRecursiveEvaluator {
     return expr.apply(context);
   }
 
-  private async _evalAsyncArgs(args: E.Expression[], mapping: RDF.Bindings): Promise<E.TermExpression[]> {
-    const argPromises = args.map(arg => this.evaluate(arg, mapping));
-    return await Promise.all(argPromises);
-  }
-
   private async evalNamed(expr: E.Named, mapping: RDF.Bindings): Promise<E.Term> {
     return expr.apply(
       {
-        args: await this._evalAsyncArgs(expr.args, mapping),
+        args: expr.args,
         mapping,
         exprEval: this.expressionEvaluator,
 
@@ -109,7 +104,7 @@ export class AsyncRecursiveEvaluator {
 
   private async evalAsyncExtension(expr: AsyncExtension, mapping: RDF.Bindings): Promise<E.Term> {
     return await expr.apply({
-      args: await this._evalAsyncArgs(expr.args, mapping),
+      args: expr.args,
       mapping,
       exprEval: this.expressionEvaluator,
 

diff --git a/packages/expression-evaluator/lib/functions/Core.ts b/packages/expression-evaluator/lib/functions/Core.ts
@@ -42,15 +42,18 @@ export abstract class BaseFunction<Operator> implements IFunctionExpression {
    * instance depending on the runtime types. We then just apply this function
    * to the args.
    */
-  public syncApply(args: E.TermExpression[], exprEval: ExpressionEvaluator): E.TermExpression {
+  public applyOnTerms(args: E.TermExpression[], exprEval: ExpressionEvaluator): E.TermExpression {
     const concreteFunction =
       this.monomorph(args, exprEval.context.superTypeProvider, exprEval.context.functionArgumentsCache) ||
       this.handleInvalidTypes(args);
     return concreteFunction(exprEval)(args);
   }
 
-  public async apply({ args, exprEval }: IEvalContext): Promise<E.TermExpression> {
-    return this.syncApply(<E.TermExpression[]> args, exprEval);
+  public async apply({ args, exprEval, mapping }: IEvalContext): Promise<E.TermExpression> {
+    return this.applyOnTerms(
+      await Promise.all(args.map(arg => exprEval.evaluator.evaluate(arg, mapping))),
+      exprEval,
+    );
   }
 
   protected abstract handleInvalidTypes(args: E.TermExpression[]): never;

diff --git a/packages/expression-evaluator/lib/functions/RegularFunctions.ts b/packages/expression-evaluator/lib/functions/RegularFunctions.ts
@@ -198,10 +198,10 @@ const equality = {
       exprEval => ([ left, right ]) => {
         const op: RegularFunction = new RegularFunction(RegularOperator.EQUAL, equality);
         return bool(
-          (<E.BooleanLiteral> op.syncApply([ (<Quad> left).subject, (<Quad> right).subject ], exprEval)).coerceEBV() &&
-          (<E.BooleanLiteral> op.syncApply([ (<Quad> left).predicate, (<Quad> right).predicate ], exprEval)).coerceEBV() &&
-          (<E.BooleanLiteral> op.syncApply([ (<Quad> left).object, (<Quad> right).object ], exprEval)).coerceEBV() &&
-          (<E.BooleanLiteral> op.syncApply([ (<Quad> left).graph, (<Quad> right).graph ], exprEval)).coerceEBV(),
+          (<E.BooleanLiteral> op.applyOnTerms([ (<Quad> left).subject, (<Quad> right).subject ], exprEval)).coerceEBV() &&
+          (<E.BooleanLiteral> op.applyOnTerms([ (<Quad> left).predicate, (<Quad> right).predicate ], exprEval)).coerceEBV() &&
+          (<E.BooleanLiteral> op.applyOnTerms([ (<Quad> left).object, (<Quad> right).object ], exprEval)).coerceEBV() &&
+          (<E.BooleanLiteral> op.applyOnTerms([ (<Quad> left).graph, (<Quad> right).graph ], exprEval)).coerceEBV(),
         );
       },
       false,
@@ -243,7 +243,7 @@ const inequality = {
     .set([ 'term', 'term' ], expressionEvaluator =>
       ([ first, second ]) =>
         bool(!(<E.BooleanLiteral> regularFunctions[C.RegularOperator.EQUAL]
-          .syncApply([ first, second ], expressionEvaluator)).typedValue))
+          .applyOnTerms([ first, second ], expressionEvaluator)).typedValue))
     .collect(),
 };
 
@@ -290,7 +290,7 @@ const greaterThan = {
     .set([ 'term', 'term' ], expressionEvaluator =>
       ([ first, second ]) =>
         // X < Y -> Y > X
-        regularFunctions[C.RegularOperator.LT].syncApply([ second, first ], expressionEvaluator))
+        regularFunctions[C.RegularOperator.LT].applyOnTerms([ second, first ], expressionEvaluator))
     .collect(),
 };
 
@@ -303,8 +303,8 @@ const lesserThanEqual = {
         // First check if the first is lesser than the second, then check if they are equal.
         // Doing this, the correct error will be thrown, each type that has a lesserThanEqual has a matching lesserThan.
         bool(
-          (<E.BooleanLiteral> regularFunctions[C.RegularOperator.LT].syncApply([ first, second ], exprEval)).typedValue ||
-          (<E.BooleanLiteral> regularFunctions[C.RegularOperator.EQUAL].syncApply([ first, second ], exprEval)).typedValue,
+          (<E.BooleanLiteral> regularFunctions[C.RegularOperator.LT].applyOnTerms([ first, second ], exprEval)).typedValue ||
+          (<E.BooleanLiteral> regularFunctions[C.RegularOperator.EQUAL].applyOnTerms([ first, second ], exprEval)).typedValue,
         ))
     .collect(),
 };
@@ -315,7 +315,7 @@ const greaterThanEqual = {
     .set([ 'term', 'term' ], exprEval =>
       ([ first, second ]) =>
         // X >= Y -> Y <= X
-        regularFunctions[C.RegularOperator.LTE].syncApply([ second, first ], exprEval))
+        regularFunctions[C.RegularOperator.LTE].applyOnTerms([ second, first ], exprEval))
     .collect(),
 };
 

diff --git a/packages/expression-evaluator/lib/functions/SpecialFunctions.ts b/packages/expression-evaluator/lib/functions/SpecialFunctions.ts
@@ -180,7 +180,7 @@ async function inRecursiveAsync(
     const nextExpression = args.shift()!;
     const next = await exprEval.evaluator.evaluate(nextExpression, mapping);
     const isEqual = regularFunctions[C.RegularOperator.EQUAL];
-    if ((<E.BooleanLiteral> isEqual.syncApply([ needle, next ], exprEval)).typedValue) {
+    if ((<E.BooleanLiteral> isEqual.applyOnTerms([ needle, next ], exprEval)).typedValue) {
       return bool(true);
     }
     return inRecursiveAsync(needle, context, [ ...results, false ]);

diff --git a/packages/expression-evaluator/test/unit/functions/OverloadTree-test.ts b/packages/expression-evaluator/test/unit/functions/OverloadTree-test.ts
@@ -98,16 +98,16 @@ describe('OverloadTree', () => {
     const one = new IntegerLiteral(1);
     const two = new IntegerLiteral(2);
     expect(functionArgumentsCache['+']).toBeUndefined();
-    const res = regularFunctions['+'].syncApply([ one, two ], expressionEvaluator);
+    const res = regularFunctions['+'].applyOnTerms([ one, two ], expressionEvaluator);
     expect(res.str()).toEqual('3');
     // One time lookup + one time add
     expect(functionArgumentsCache['+']).not.toBeUndefined();
-    regularFunctions['+'].syncApply([ two, one ], expressionEvaluator);
+    regularFunctions['+'].applyOnTerms([ two, one ], expressionEvaluator);
 
     const innerSpy = jest.fn();
     const spy = jest.fn(() => innerSpy);
     functionArgumentsCache['+']!.cache![TypeURL.XSD_INTEGER].cache![TypeURL.XSD_INTEGER]!.func = spy;
-    regularFunctions['+'].syncApply([ one, two ], expressionEvaluator);
+    regularFunctions['+'].applyOnTerms([ one, two ], expressionEvaluator);
     expect(spy).toHaveBeenCalled();
     expect(innerSpy).toHaveBeenCalled();
   });
@@ -117,15 +117,15 @@ describe('OverloadTree', () => {
     const one = new IntegerLiteral(1);
     const two = new IntegerLiteral(2);
     expect(functionArgumentsCache.substr).toBeUndefined();
-    expect(regularFunctions.substr.syncApply([ apple, one, two ], expressionEvaluator).str()).toBe('ap');
+    expect(regularFunctions.substr.applyOnTerms([ apple, one, two ], expressionEvaluator).str()).toBe('ap');
 
     expect(functionArgumentsCache.substr).toBeDefined();
     const interestCache = functionArgumentsCache.substr
       .cache![TypeURL.XSD_STRING].cache![TypeURL.XSD_INTEGER];
     expect(interestCache.func).toBeUndefined();
     expect(interestCache.cache![TypeURL.XSD_INTEGER]).toBeDefined();
 
-    expect(regularFunctions.substr.syncApply([ apple, one ], expressionEvaluator).str()).toBe(String('apple'));
+    expect(regularFunctions.substr.applyOnTerms([ apple, one ], expressionEvaluator).str()).toBe(String('apple'));
     const interestCacheNew = functionArgumentsCache.substr
       .cache![TypeURL.XSD_STRING].cache![TypeURL.XSD_INTEGER];
     expect(interestCacheNew).toBeDefined();