@trebco/treb 31.9.1 → 32.3.1

package/treb-calculator/src/expression-calculator.ts

@@ -27,14 +27,18 @@ import type { Cell, ICellAddress,
          UndefinedUnion,
          ComplexUnion, 
          DimensionedQuantityUnion,
-         IArea} from 'treb-base-types';
+         IArea,
+         FunctionUnion} from 'treb-base-types';
 import { ValueType, GetValueType, Area } from 'treb-base-types';
 import type { Parser, ExpressionUnit, UnitBinary, UnitIdentifier,
-         UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference } from 'treb-parser';
+         UnitGroup, UnitUnary, UnitAddress, UnitRange, UnitCall, UnitDimensionedQuantity, UnitStructuredReference, 
+         UnitImplicitCall,
+         UnitArray} from 'treb-parser';
 import type { DataModel, MacroFunction, Sheet } from 'treb-data-model';
-import { NameError, ReferenceError, ExpressionError, UnknownError, SpillError, ValueError } from './function-error';
+import { NameError, ReferenceError, ExpressionError, UnknownError, SpillError, ValueError, ArgumentError } from './function-error';
 
 import * as Primitives from './primitives';
+import type { ContextResult } from './descriptors';
 
 //////////
 
@@ -82,10 +86,17 @@ export interface ReferenceMetadata {
   format?: string;
 }
 
+export type BindingFrame = Record<string, ExpressionUnit>; // FIXME (type?)
+export type PositionalFrame = ExpressionUnit[];
+
 export interface CalculationContext {
   address: ICellAddress;
   area?: IArea;
   volatile: boolean;
+
+  /** new for lambdas */
+  bindings: BindingFrame[];
+
 }
 
 export class ExpressionCalculator {
@@ -93,6 +104,7 @@ export class ExpressionCalculator {
   public context: CalculationContext = {
     address: { row: -1, column: -1 },
     volatile: false,
+    bindings: [],
   };
 
   // --- public API -----------------------------------------------------------
@@ -438,6 +450,164 @@ export class ExpressionCalculator {
       
   }
 
+  /**
+   * split out from ImplicitCall so we can reuse
+   */
+  public ImplicitCallTail(result: FunctionUnion, args: ExpressionUnit[]) {
+
+    const value = result.value as {
+      bindings: ExpressionUnit[];
+      func: ExpressionUnit|undefined;
+    };
+
+    if (!value.func || !value.bindings) {
+      return ExpressionError();
+    }
+
+    // let frame = value.bindings(expr.args);
+
+    const frame: BindingFrame = {};
+
+    for (let i = 0; i < value.bindings.length; i++) {
+      const name = value.bindings[i];
+      if (name?.type === 'identifier') {
+        frame[name.name.toUpperCase()] = args[i] || { type: 'missing' };
+      }
+      else { 
+        // should not happen, error
+        return ExpressionError();
+      }
+    }
+
+    // frame = this.NormalizeBindings(frame); // inline
+
+    const munged = JSON.parse(JSON.stringify(value.func));
+    
+    this.parser.Walk2(munged, (unit: ExpressionUnit) => {
+      if (unit.type === 'identifier') {
+        const upper_case = unit.name.toUpperCase();
+        const binding = frame[upper_case];
+        if (binding) {
+          return JSON.parse(JSON.stringify(binding));
+        }
+      }
+      return true;
+    });
+    
+    // console.info({frame, func, munged});
+   
+    // const exec_result = this.CalculateExpression(munged as ExtendedExpressionUnit);
+    // return exec_result || ExpressionError();
+
+    return this.CalculateExpression(munged as ExtendedExpressionUnit);
+
+  }
+
+  /**
+   * an FP call will need to set bindings and call an expression, 
+   * possibly multiple times. this is a support function for that.
+   */
+  protected Apply(fn: FunctionUnion, args: UnionValue[]) {
+
+    // kind of going backwards here, converting values to expressions...
+    // the reason is that we rewrite lambdas to support recursion
+
+    const mapped: ExpressionUnit[] = args.map(arg => {
+      switch (arg.type) {
+        case ValueType.number:
+        case ValueType.boolean:
+        case ValueType.string:
+          return {
+            type: 'literal', value: arg.value, id: 0, position: 0,
+          }
+  
+        case ValueType.error:
+          return {
+            type: 'literal', value: '#' + arg.value, id: 0, position: 0,
+          }
+  
+        case ValueType.array:
+          {
+            const values: UnitArray['values'] = [];
+            for (let c = 0; c < arg.value.length; c++) {
+              const col = arg.value[c];
+              const mapped_col: UnitArray['values'][0] = [];
+              for (let r = 0; r < col.length; r++ ) {
+                const val = col[r];
+                switch (val.type) {
+                  case ValueType.boolean:
+                  case ValueType.number:
+                  case ValueType.string:
+                    mapped_col.push(val.value || undefined);
+                    break;
+                  default:
+                    console.warn('unhandled array value', val);
+                    mapped_col.push(undefined);
+                }
+              }
+              values.push(mapped_col);
+            }
+
+            return {
+              type: 'array', 
+              values,
+              id: 0, position: 0,
+            };
+          }
+  
+        default:
+          console.warn('unhandled parameter value', arg);
+  
+      }
+      return { type: 'missing', id: 0 };
+ 
+    });
+
+    return this.ImplicitCallTail(fn, mapped);
+
+  }
+
+  /** 
+   * this method can take a `call` type if it looked like a call at 
+   * the parsing stage, it's a simple translation between the two
+   */
+  protected ImplicitCall(): (expr: UnitImplicitCall|UnitCall) => UnionValue {
+    return (expr: UnitImplicitCall|UnitCall) => {
+
+      if (expr.type === 'call') {
+        expr = {
+          type: 'implicit-call',
+          args: expr.args,
+          call: {
+            type: 'identifier',
+            name: expr.name,
+            position: expr.position,
+            id: 0,
+          },
+          position: expr.position,
+          id: 0,
+        };
+      }
+
+      const result = this.CalculateExpression(expr.call as ExtendedExpressionUnit);
+
+      if (result.type === ValueType.function) {
+        return this.ImplicitCallTail(result, expr.args)
+      }
+
+      return ExpressionError();
+      
+    };
+  }
+
+  protected NormalizeBindings(context: BindingFrame) {
+    const frame: Record<string, ExpressionUnit> = {};
+    for (const [key, value] of Object.entries(context)) {
+      frame[key.toUpperCase()] = value;
+    }
+    return frame;
+  }
+
   /** 
    * excute a function call 
    */
@@ -451,6 +621,18 @@ export class ExpressionCalculator {
 
     if (!func) {
 
+      const upper_case = outer.name.toUpperCase();
+
+      const binding = this.LookupBinding(upper_case);
+      if (binding) {
+        return this.ImplicitCall();
+      }
+
+      const named = this.data_model.GetName(upper_case, this.context.address.sheet_id || 0);
+      if (named) {
+        return this.ImplicitCall();
+      }
+      
       if (process.env.NODE_ENV !== 'production') {
         console.info('(dev) missing function', outer.name);
       }
@@ -474,9 +656,36 @@ export class ExpressionCalculator {
       let skip_argument_index = -1;
       let argument_error: UnionValue|undefined;
 
-      const argument_descriptors = func.arguments || []; // map
+      // possibly create a binding frame. if we do that we may need
+      // to adjust the arguments as well (and the descriptors)
+
+      let args = expr.args;
+      let argument_descriptors = func.arguments || []; // map
+
+      let binding: ContextResult|undefined;
+      if (func.create_binding_context) {
+
+        // if this does not return a binding frame, it's an error.
+
+        binding = func.create_binding_context.call(0, {
+          args: expr.args, 
+          descriptors: argument_descriptors,
+        }); 
 
-      const mapped_args = expr.args.map((arg, arg_index) => {
+        if (binding) {
+          args = binding.args;
+          if (binding.argument_descriptors) {
+            argument_descriptors = binding.argument_descriptors;
+          }
+          this.context.bindings.unshift(this.NormalizeBindings(binding.context));
+        }
+        else {
+          argument_error = ArgumentError();
+        }
+
+      }
+
+      const mapped_args = args.map((arg, arg_index) => {
 
         // short circuit
         if (argument_error) { 
@@ -485,8 +694,18 @@ export class ExpressionCalculator {
 
         // get descriptor. if the number of arguments exceeds 
         // the number of descriptors, recycle the last one
+
+        // FIXME: we have a repeat flag, so we should repeat the 
+        // correct argument(s). I guess we could default to this
+        // behavior.
+
         const descriptor = argument_descriptors[Math.min(arg_index, argument_descriptors.length - 1)] || {}; 
-        
+
+        // new for lambdas
+        if (descriptor.passthrough) {
+          return arg;
+        }
+
         // if function, wrong branch
         if (arg_index === skip_argument_index) { 
           return descriptor.boxed ? { type: ValueType.undefined } : undefined;
@@ -559,6 +778,10 @@ export class ExpressionCalculator {
 
       });
 
+      if (binding) {
+        this.context.bindings.shift();
+      }
+
       if (argument_error) {
         return argument_error;
       }
@@ -571,11 +794,12 @@ export class ExpressionCalculator {
           start: { ...this.context.area.start, },
           end: { ...this.context.area.end, },
         } : undefined,
+        apply: func.fp ? this.Apply.bind(this) : undefined,
       };
 
-      if (func.return_type === 'reference') {
+      const result = func.fn.apply(ctx, mapped_args);
 
-        const result = func.fn.apply(ctx, mapped_args);
+      if (func.return_type === 'reference') {
         
         if (return_reference) { 
           return result; 
@@ -594,7 +818,7 @@ export class ExpressionCalculator {
 
       }
 
-      return func.fn.apply(ctx, mapped_args);
+      return result; // func.fn.apply(ctx, mapped_args);
 
     };
 
@@ -1012,11 +1236,11 @@ export class ExpressionCalculator {
 
     switch (upper_case){
     case 'FALSE':
-    case 'F':
+    // case 'F':
       return () => {return {value: false, type: ValueType.boolean}};
 
     case 'TRUE':
-    case 'T':
+    // case 'T':
       return () => {return {value: true, type: ValueType.boolean}};
 
     case 'UNDEFINED':
@@ -1025,8 +1249,13 @@ export class ExpressionCalculator {
 
     return () => {
 
-      const named = this.data_model.GetName(upper_case, this.context.address.sheet_id || 0);
+      const binding = this.LookupBinding(upper_case);
+      if (binding) {
+        return this.CalculateExpression(binding as ExtendedExpressionUnit);
+      }
       
+      const named = this.data_model.GetName(upper_case, this.context.address.sheet_id || 0);
+ 
       switch (named?.type) {
         case 'range':
           if (named.area.count === 1) {
@@ -1046,6 +1275,24 @@ export class ExpressionCalculator {
 
   }
 
+  /**
+   * look up an identifier in any binding frames. we do LIFO binding.
+   * 
+   * @param name 
+   * @returns 
+   */
+  protected LookupBinding(name: string) {
+    name = name.toUpperCase();
+    for (const frame of this.context.bindings) {
+      const value = frame[name];
+      if (value) {
+        return value;
+      }
+    }
+
+    return undefined;
+  }
+
   protected GroupExpression(x: UnitGroup): (expr: UnitGroup) => UnionValue /*UnionOrArray*/ {
 
     // a group is an expression in parentheses, either explicit
@@ -1075,6 +1322,10 @@ export class ExpressionCalculator {
     }
 
     switch (expr.type){
+
+    case 'implicit-call':
+      return (expr.fn = this.ImplicitCall())(expr);
+
     case 'call':
       {
         const macro = this.data_model.macro_functions.get(expr.name.toUpperCase());

package/treb-calculator/src/functions/base-functions.ts

@@ -351,6 +351,54 @@ export const BaseFunctionLibrary: FunctionMap = {
     fn: () => { return { type: ValueType.number, value: Math.random() }},
   },
 
+  RandArray: {
+    volatile: true,
+    arguments: [
+      {name: 'rows'},
+      {name: 'columns'},
+      {name: 'min'}, 
+      {name: 'max'},
+      {name: 'integer'},
+    ],
+    description: 'Returns an array of uniformly-distributed random numbers',
+    fn: (rows = 1, columns = 1, min = 0, max = 1, integer = false) => {
+      const value: UnionValue[][] = [];
+
+      if (integer) {
+        const range = max - min + 1;
+        for (let i = 0; i < rows; i++) {
+          const row: UnionValue[] = [];
+          for (let j = 0; j < columns; j++) {
+            row.push({
+              type: ValueType.number,
+              value: Math.floor(Math.random() * range + min),
+            });
+          }
+          value.push(row);
+        }
+      }
+      else {
+        const range = max - min;
+
+        for (let i = 0; i < rows; i++) {
+          const row: UnionValue[] = [];
+          for (let j = 0; j < columns; j++) {
+            row.push({
+              type: ValueType.number,
+              value: Math.random() * range + min,
+            });
+          }
+          value.push(row);
+        }
+      }
+
+      return {
+        type: ValueType.array,
+        value,
+      }
+    },
+  },
+
   RandBetween: {
     arguments: [{name: 'min'}, {name: 'max'}],
     volatile: true,
@@ -2719,6 +2767,7 @@ const block_list = [
   'imul',
   'clz32',
   'fround',
+  'f16round',
 ];
 
 const block_map: Record<string, string> = {};