@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -1,4 +1,5 @@
-import { AtomicFieldType, StructDef } from '../../../model/malloy_types';
+import { StructDef } from '../../../model/malloy_types';
+import { BinaryMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace, QueryFieldSpace } from '../types/field-space';
@@ -22,7 +23,6 @@ export declare class ConstantExpression extends ExpressionDef {
     getExpression(_fs: FieldSpace): ExprValue;
     private get constantFs();
     constantValue(): ExprValue;
-    constantCondition(type: AtomicFieldType): ExprValue;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(fs: FieldSpace): ExprValue | undefined;
 }

package/dist/lang/ast/expressions/constant-expression.js

@@ -23,10 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstantExpression = exports.ConstantFieldSpace = void 0;
-const comparison_1 = require("../types/comparison");
 const expression_def_1 = require("../types/expression-def");
-const expr_compare_1 = require("./expr-compare");
-const utils_1 = require("./utils");
 class ConstantFieldSpace {
     constructor() {
         this.type = 'fieldSpace';
@@ -57,21 +54,6 @@ class ConstantFieldSpace {
     }
 }
 exports.ConstantFieldSpace = ConstantFieldSpace;
-class DollarReference extends expression_def_1.ExpressionDef {
-    constructor(refType) {
-        super();
-        this.refType = refType;
-        this.elementType = '$';
-    }
-    getExpression(_fs) {
-        return {
-            dataType: this.refType,
-            value: [{ type: 'applyVal' }],
-            expressionType: 'scalar',
-            evalSpace: 'constant',
-        };
-    }
-}
 class ConstantExpression extends expression_def_1.ExpressionDef {
     constructor(expr) {
         super({ expr: expr });
@@ -90,11 +72,6 @@ class ConstantExpression extends expression_def_1.ExpressionDef {
     constantValue() {
         return this.expr.getExpression(this.constantFs);
     }
-    constantCondition(type) {
-        const compareAndContrast = new expr_compare_1.ExprCompare(new DollarReference(type), comparison_1.Comparison.EqualTo, this.expr);
-        const application = compareAndContrast.getExpression(this.constantFs);
-        return { ...application, value: (0, utils_1.compressExpr)(application.value) };
-    }
     apply(fs, op, expr) {
         return this.expr.apply(fs, op, expr);
     }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -68,17 +68,9 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                     exprVal = {
                         dataType: footType.dataType,
                         expressionType: footType.expressionType,
-                        value: [
-                            footType.evalSpace === 'output'
-                                ? {
-                                    type: 'outputField',
-                                    name: this.source.refString,
-                                }
-                                : {
-                                    type: 'field',
-                                    path: this.source.path,
-                                },
-                        ],
+                        value: footType.evalSpace === 'output'
+                            ? { node: 'outputField', name: this.source.refString }
+                            : { node: 'field', path: this.source.path },
                         evalSpace: footType.evalSpace,
                     };
                     structPath = this.source.path;
@@ -140,7 +132,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             expressionType: 'scalar',
         })) {
             const f = {
-                type: 'aggregate',
+                node: 'aggregate',
                 function: this.func,
                 e: exprVal.value,
             };
@@ -150,7 +142,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             return {
                 dataType: this.returns(exprVal),
                 expressionType: 'aggregate',
-                value: [f],
+                value: f,
                 evalSpace: 'output',
             };
         }
@@ -164,7 +156,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         if (this.source) {
             const lookup = this.source.getField(fs);
             if (lookup.found) {
-                const sfd = [{ type: 'field', path: this.source.path }];
+                const sfd = { node: 'field', path: this.source.path };
                 result.push(...getJoinUsage(fs, sfd));
             }
         }
@@ -226,31 +218,29 @@ function getJoinUsage(fs, expr) {
             throw new Error('expected a field def or struct');
         }
     };
-    (0, utils_1.exprWalk)(expr, frag => {
-        if (typeof frag !== 'string') {
-            if (frag.type === 'field') {
-                const def = lookup(fs, frag.path);
-                if (def.def.type !== 'struct' && def.def.type !== 'turtle') {
-                    if (def.def.e) {
-                        const defUsage = getJoinUsage(def.fs, def.def.e);
-                        result.push(...defUsage.map(r => [...def.relationship, ...r]));
-                    }
-                    else {
-                        result.push(def.relationship);
-                    }
-                }
-            }
-            else if (frag.type === 'source-reference') {
-                if (frag.path) {
-                    const def = lookup(fs, frag.path);
-                    result.push(def.relationship);
+    for (const frag of (0, utils_1.exprWalk)(expr)) {
+        if (frag.node === 'field') {
+            const def = lookup(fs, frag.path);
+            if (def.def.type !== 'struct' && def.def.type !== 'turtle') {
+                if (def.def.e) {
+                    const defUsage = getJoinUsage(def.fs, def.def.e);
+                    result.push(...defUsage.map(r => [...def.relationship, ...r]));
                 }
                 else {
-                    result.push([]);
+                    result.push(def.relationship);
                 }
             }
         }
-    });
+        else if (frag.node === 'source-reference') {
+            if (frag.path) {
+                const def = lookup(fs, frag.path);
+                result.push(def.relationship);
+            }
+            else {
+                result.push([]);
+            }
+        }
+    }
     return result;
 }
 function getJoinUsagePaths(sourceRelationship, joinUsage) {

package/dist/lang/ast/expressions/expr-alternation-tree.d.ts

@@ -1,11 +1,14 @@
 import { ExprValue } from '../types/expr-value';
-import { BinaryBoolean } from './binary-boolean';
 import { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
-export declare class ExprAlternationTree extends BinaryBoolean<'|' | '&'> {
+import { BinaryMalloyOperator } from '../types/binary_operators';
+export declare class ExprAlternationTree extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: '|' | '&';
+    readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, op: '|' | '&', right: ExpressionDef);
-    apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, applyOp: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -25,11 +25,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAlternationTree = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
-const binary_boolean_1 = require("./binary-boolean");
-const utils_1 = require("./utils");
-class ExprAlternationTree extends binary_boolean_1.BinaryBoolean {
+const expression_def_1 = require("../types/expression-def");
+class ExprAlternationTree extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
-        super(left, op, right);
+        super({ left, right });
+        this.left = left;
+        this.op = op;
+        this.right = right;
         this.elementType = 'alternation';
         this.elementType = `${op}alternation${op}`;
     }
@@ -40,7 +42,10 @@ class ExprAlternationTree extends binary_boolean_1.BinaryBoolean {
             dataType: 'boolean',
             expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
             evalSpace: (0, malloy_types_1.mergeEvalSpaces)(choice1.evalSpace, choice2.evalSpace),
-            value: (0, utils_1.compose)(choice1.value, this.op === '&' ? 'and' : 'or', choice2.value),
+            value: {
+                node: this.op === '&' ? 'and' : 'or',
+                kids: { left: choice1.value, right: choice2.value },
+            },
         };
     }
     requestExpression(_fs) {

package/dist/lang/ast/expressions/expr-cast.js

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCast = void 0;
 const time_utils_1 = require("../time-utils");
 const expression_def_1 = require("../types/expression-def");
-const utils_1 = require("./utils");
 class ExprCast extends expression_def_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
         super({ expr: expr });
@@ -58,7 +57,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
         return {
             dataType,
             expressionType: expr.expressionType,
-            value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe)),
+            value: (0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe),
             evalSpace: expr.evalSpace,
         };
     }

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -55,7 +55,10 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
             ...whenNull,
             dataType: maybeNull.dataType === 'error' ? whenNull.dataType : maybeNull.dataType,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
-            value: (0, model_1.mkExpr) `COALESCE(${maybeNull.value},${whenNull.value})`,
+            value: {
+                node: 'coalesce',
+                kids: { left: maybeNull.value, right: whenNull.value },
+            },
             evalSpace: (0, model_1.mergeEvalSpaces)(maybeNull.evalSpace, whenNull.evalSpace),
         };
     }

package/dist/lang/ast/expressions/expr-compare.d.ts

@@ -1,10 +1,10 @@
-import { Comparison } from '../types/comparison';
+import { CompareMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { BinaryBoolean } from './binary-boolean';
-export declare class ExprCompare extends BinaryBoolean<Comparison> {
+export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
     elementType: string;
-    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
+    constructor(left: ExpressionDef, op: CompareMalloyOperator, right: ExpressionDef);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -27,7 +27,7 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
-        super('count_distinct', expr);
+        super('distinct', expr);
         this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
     }
 }

package/dist/lang/ast/expressions/expr-count.js

@@ -39,9 +39,9 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
     }
     getExpression(_fs) {
         const ret = {
-            type: 'aggregate',
+            node: 'aggregate',
             function: 'count',
-            e: [],
+            e: { node: '' },
         };
         if (this.source) {
             ret.structPath = this.source.path;
@@ -49,7 +49,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
         return {
             dataType: 'number',
             expressionType: 'aggregate',
-            value: [ret],
+            value: ret,
             evalSpace: 'output',
         };
     }

package/dist/lang/ast/expressions/expr-func.js

@@ -28,7 +28,7 @@ const ast_utils_1 = require("../ast-utils");
 const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const expression_def_1 = require("../types/expression-def");
 const field_space_1 = require("../types/field-space");
-const utils_1 = require("./utils");
+const utils_1 = require("../../../model/utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args, isRaw, rawType, source) {
         super({ args: args });
@@ -67,14 +67,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 else {
                     collectType = expr.dataType;
                 }
-                funcCall.push(...expr.value);
+                funcCall.push(expr.value);
             }
             funcCall.push(')');
             const dataType = (_b = (_a = this.rawType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : 'number';
             return {
                 dataType,
                 expressionType,
-                value: (0, utils_1.compressExpr)(funcCall),
+                value: (0, utils_1.composeSQLExpr)(funcCall),
                 evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...argExprsWithoutImplicit.map(e => e.evalSpace)),
             };
         }
@@ -104,7 +104,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     implicitExpr = {
                         dataType: footType.dataType,
                         expressionType: footType.expressionType,
-                        value: [{ type: 'field', path: this.source.path }],
+                        value: { node: 'field', path: this.source.path },
                         evalSpace: footType.evalSpace,
                     };
                     structPath = this.source.path.slice(0, -1);
@@ -175,14 +175,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             return (0, ast_utils_1.errorFor)('cannot call with source');
         }
         const frag = {
-            type: 'function_call',
+            node: 'function_call',
             overload,
             name: this.name,
-            args: argExprs.map(x => x.value),
+            kids: { args: argExprs.map(x => x.value) },
             expressionType,
             structPath,
         };
-        let funcCall = [frag];
+        let funcCall = frag;
         const dialect = (_e = fs.dialectObj()) === null || _e === void 0 ? void 0 : _e.name;
         const dialectOverload = dialect ? overload.dialect[dialect] : undefined;
         // TODO add in an error if you use an asymmetric function in BQ
@@ -204,7 +204,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     const allObs = props.orderBys.flatMap(orderBy => isAnalytic
                         ? orderBy.getAnalyticOrderBy(fs)
                         : orderBy.getAggregateOrderBy(fs, allowExpression));
-                    frag.orderBy = allObs;
+                    frag.kids.orderBy = allObs;
                 }
                 else {
                     props.orderBys[0].log(`Function \`${this.name}\` does not support \`order_by\``);
@@ -251,14 +251,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 return (0, ast_utils_1.errorFor)('sql_function used without enabling');
             }
             const str = argExprs[0].value;
-            if (str.length !== 1 ||
-                typeof str[0] === 'string' ||
-                str[0].type !== 'dialect' ||
-                str[0].function !== 'stringLiteral') {
+            if (str.node !== 'stringLiteral') {
                 this.log(`Invalid string literal for \`${func.name}\``);
             }
             else {
-                const literal = str[0].literal;
+                const literal = str.literal;
                 const parts = parseSQLInterpolation(literal);
                 const unsupportedInterpolations = parts
                     .filter(part => part.type === 'interpolation' && part.name.includes('.'))
@@ -278,7 +275,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                         expr.push(part.value);
                     }
                     else if (part.name === 'TABLE') {
-                        expr.push({ type: 'source-reference' });
+                        expr.push({ node: 'source-reference' });
                     }
                     else {
                         const name = new field_space_1.FieldName(part.name);
@@ -289,14 +286,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                             return (0, ast_utils_1.errorFor)('invalid interpolated field');
                         }
                         if (result.found.refType === 'parameter') {
-                            expr.push({ type: 'parameter', path: [part.name] });
+                            expr.push({ node: 'parameter', path: [part.name] });
                         }
                         else {
-                            expr.push({ type: 'field', path: [part.name] });
+                            expr.push({ node: 'field', path: [part.name] });
                         }
                     }
                 }
-                funcCall = [{ type: 'sql-string', e: expr }];
+                funcCall = (0, utils_1.composeSQLExpr)(expr);
             }
         }
         if (type.dataType === 'any') {
@@ -317,7 +314,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         return {
             dataType: type.dataType,
             expressionType,
-            value: (0, utils_1.compressExpr)(funcCall),
+            value: funcCall,
             evalSpace,
         };
     }

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -59,14 +59,11 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
                 timeframe: timeframe,
             };
             if (this.truncate) {
-                tsVal.value = [
-                    {
-                        type: 'dialect',
-                        function: 'trunc',
-                        expr: { value: exprVal.value, valueType: exprVal.dataType },
-                        units: timeframe,
-                    },
-                ];
+                tsVal.value = {
+                    node: 'trunc',
+                    e: { ...exprVal.value, dataType: exprVal.dataType },
+                    units: timeframe,
+                };
             }
             return tsVal;
         }
@@ -102,13 +99,14 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     // }
     toRange(fs) {
         const begin = this.getExpression(fs);
+        const one = { node: 'numberLiteral', literal: '1' };
         if (begin.dataType === 'timestamp') {
             const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);
-            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', one, this.units), begin.expressionType);
             return new range_1.Range(beginTS, endTS);
         }
         const beginDate = new expr_time_1.ExprTime('date', begin.value, begin.expressionType);
-        const endAt = (0, time_utils_1.timeOffset)('date', begin.value, '+', ['1'], this.units);
+        const endAt = (0, time_utils_1.timeOffset)('date', begin.value, '+', one, this.units);
         const endDate = new expr_time_1.ExprTime('date', endAt, begin.expressionType);
         return new range_1.Range(beginDate, endDate);
     }

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -44,10 +44,10 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
                 return {
                     ...td,
                     evalSpace: td.evalSpace === 'constant' ? 'constant' : 'output',
-                    value: [{ type: 'outputField', name: this.refString }],
+                    value: { node: 'outputField', name: this.refString },
                 };
             }
-            const value = [{ type: def.found.refType, path: this.fieldReference.path }];
+            const value = { node: def.found.refType, path: this.fieldReference.path };
             // We think that aggregates are more 'output' like, but maybe we will reconsider that...
             const evalSpace = (0, malloy_types_1.expressionIsAggregate)(td.expressionType)
                 ? 'output'

package/dist/lang/ast/expressions/expr-minus.js

@@ -36,10 +36,11 @@ class ExprMinus extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
         if (fragtype_utils_1.FT.typeIn(expr, this.legalChildTypes)) {
-            if (expr.value.length > 1) {
-                return { ...expr, dataType: 'number', value: ['-(', ...expr.value, ')'] };
-            }
-            return { ...expr, dataType: 'number', value: ['-', ...expr.value] };
+            return {
+                ...expr,
+                dataType: 'number',
+                value: { node: 'unary-', e: expr.value },
+            };
         }
         return (0, ast_utils_1.errorFor)('negate requires number');
     }

package/dist/lang/ast/expressions/expr-not.js

@@ -38,7 +38,7 @@ class ExprNot extends unary_1.Unary {
         return {
             ...notThis,
             dataType: 'boolean',
-            value: doNot ? (0, utils_1.nullsafeNot)(notThis.value) : ['false'],
+            value: doNot ? (0, utils_1.nullsafeNot)(notThis.value) : { node: 'false' },
         };
     }
 }

package/dist/lang/ast/expressions/expr-now.js

@@ -35,12 +35,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
             expressionType: 'scalar',
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',
-            value: [
-                {
-                    type: 'dialect',
-                    function: 'now',
-                },
-            ],
+            value: { node: 'now' },
         };
     }
 }

package/dist/lang/ast/expressions/expr-null.js

@@ -32,7 +32,7 @@ class ExprNULL extends expression_def_1.ExpressionDef {
     getExpression() {
         return {
             dataType: 'null',
-            value: ['NULL'],
+            value: { node: 'null' },
             expressionType: 'scalar',
             evalSpace: 'literal',
         };

package/dist/lang/ast/expressions/expr-number.js

@@ -38,7 +38,7 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         return {
             ...fragtype_utils_1.FT.numberT,
             evalSpace: 'literal',
-            value: [{ type: 'dialect', function: 'numberLiteral', literal: this.n }],
+            value: { node: 'numberLiteral', literal: this.n },
         };
     }
 }

package/dist/lang/ast/expressions/expr-parens.js

@@ -35,7 +35,7 @@ class ExprParens extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const subExpr = this.expr.getExpression(fs);
-        return { ...subExpr, value: ['(', ...subExpr.value, ')'] };
+        return { ...subExpr, value: { node: '()', e: subExpr.value } };
     }
 }
 exports.ExprParens = ExprParens;

package/dist/lang/ast/expressions/expr-props.js

@@ -57,13 +57,10 @@ class ExprProps extends expression_def_1.ExpressionDef {
             if (this.typeCheck(this.expr, { ...expr, expressionType: 'scalar' })) {
                 return {
                     ...expr,
-                    value: [
-                        {
-                            type: 'filterExpression',
-                            e: expr.value,
-                            filterList,
-                        },
-                    ],
+                    value: {
+                        node: 'filteredExpr',
+                        kids: { e: expr.value, filterList },
+                    },
                 };
             }
             this.expr.log(`Cannot filter '${expr.dataType}' data`);

package/dist/lang/ast/expressions/expr-regex.js

@@ -34,9 +34,7 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
         return {
             dataType: 'regular expression',
             expressionType: 'scalar',
-            value: [
-                { type: 'dialect', function: 'regexpLiteral', literal: this.regex },
-            ],
+            value: { node: 'regexpLiteral', literal: this.regex },
             evalSpace: 'literal',
         };
     }

package/dist/lang/ast/expressions/expr-string.js

@@ -34,13 +34,7 @@ class ExprString extends expression_def_1.ExpressionDef {
     getExpression(_fs) {
         return {
             ...fragtype_utils_1.FT.stringT,
-            value: [
-                {
-                    type: 'dialect',
-                    function: 'stringLiteral',
-                    literal: this.value,
-                },
-            ],
+            value: { node: 'stringLiteral', literal: this.value },
             evalSpace: 'literal',
         };
     }

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -107,15 +107,14 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     dataType: 'number',
                     expressionType,
                     evalSpace,
-                    value: [
-                        {
-                            type: 'dialect',
-                            function: 'timeDiff',
-                            units: extractTo,
-                            left: { valueType, value: first.value },
-                            right: { valueType, value: last.value },
+                    value: {
+                        node: 'timeDiff',
+                        units: extractTo,
+                        kids: {
+                            left: { ...first.value, dataType: valueType },
+                            right: { ...last.value, dataType: valueType },
                         },
-                    ],
+                    },
                 };
             }
             else {
@@ -125,14 +124,11 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         dataType: 'number',
                         expressionType: argV.expressionType,
                         evalSpace: argV.evalSpace,
-                        value: [
-                            {
-                                type: 'dialect',
-                                function: 'extract',
-                                expr: { value: argV.value, valueType: argV.dataType },
-                                units: extractTo,
-                            },
-                        ],
+                        value: {
+                            node: 'extract',
+                            e: { ...argV.value, dataType: argV.dataType },
+                            units: extractTo,
+                        },
                     };
                 }
                 if (argV.dataType !== 'error') {

package/dist/lang/ast/expressions/expr-time.d.ts

@@ -1,11 +1,11 @@
-import { ExpressionType, Fragment, TimeFieldType } from '../../../model/malloy_types';
+import { Expr, ExpressionType, TimeFieldType } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
-    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
+    constructor(timeType: TimeFieldType, value: Expr, expressionType?: ExpressionType);
     getExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
 }