@malloydata/malloy 0.0.223-dev241213043533 → 0.0.223-dev241216191808

package/dist/dialect/duckdb/dialect_functions.js

@@ -7,11 +7,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DUCKDB_DIALECT_FUNCTIONS = void 0;
+const list_extract = {
+    takes: { 'value': { array: { generic: 'T' } }, 'index': 'number' },
+    generic: { 'T': ['any'] },
+    returns: { generic: 'T' },
+    impl: { sql: 'list_extract(${value}, ${index})' },
+};
 const dayname = {
     takes: { 'date_value': ['date', 'timestamp'] },
     returns: 'string',
     impl: { function: 'DAYNAME' },
 };
+const date_part = {
+    takes: { 'part': 'string', 'interval': { sql_native: 'interval' } },
+    returns: 'number',
+    impl: { function: 'DATE_PART' },
+};
+const to_seconds = {
+    takes: { 'seconds': 'number' },
+    returns: { sql_native: 'interval' },
+    impl: { function: 'TO_SECONDS' },
+};
 const to_timestamp = {
     takes: { 'epoch_seconds': 'number' },
     returns: 'timestamp',
@@ -65,10 +81,13 @@ const string_agg_distinct = {
     },
 };
 exports.DUCKDB_DIALECT_FUNCTIONS = {
+    list_extract,
     count_approx,
     dayname,
     to_timestamp,
     string_agg,
     string_agg_distinct,
+    to_seconds,
+    date_part,
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/functions/malloy_standard_functions.js

@@ -54,7 +54,7 @@ const chr = {
     impl: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE CHR(${value}) END" },
 };
 const coalesce = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'value': { variadic: { generic: 'T' } } },
     returns: { generic: 'T' },
     impl: { function: 'COALESCE' },
@@ -101,13 +101,13 @@ const floor = {
     impl: { function: 'FLOOR' },
 };
 const greatest = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'values': { variadic: { generic: 'T' } } },
     returns: { generic: 'T' },
     impl: { function: 'GREATEST' },
 };
 const ifnull = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'value': { generic: 'T' }, 'default': { generic: 'T' } },
     returns: { generic: 'T' },
     impl: { function: 'IFNULL' },
@@ -162,7 +162,7 @@ const ltrim = {
     },
 };
 const nullif = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'value1': { generic: 'T' }, 'value2': { generic: 'T' } },
     returns: { generic: 'T' },
     impl: { function: 'NULLIF' },
@@ -331,7 +331,7 @@ const stddev = {
 // Analytic functions
 const avg_moving = {
     'preceding': {
-        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
         takes: {
             'value': { measure: { generic: 'T' } },
             'preceding': { literal: 'number' },
@@ -344,7 +344,7 @@ const avg_moving = {
         },
     },
     'following': {
-        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
         takes: {
             'value': { measure: { generic: 'T' } },
             'preceding': { literal: 'number' },
@@ -359,7 +359,7 @@ const avg_moving = {
     },
 };
 const first_value = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'FIRST_VALUE', needsWindowOrderBy: true },
@@ -374,7 +374,7 @@ const LAG_TYPES = [
 ];
 const lag = {
     'bare': {
-        generic: ['T', LAG_TYPES],
+        generic: { 'T': LAG_TYPES },
         takes: {
             'value': { measure: { generic: 'T' } },
         },
@@ -382,7 +382,7 @@ const lag = {
         impl: { function: 'LAG', needsWindowOrderBy: true },
     },
     'with_offset': {
-        generic: ['T', LAG_TYPES],
+        generic: { 'T': LAG_TYPES },
         takes: {
             'value': { measure: { generic: 'T' } },
             'offset': { literal: 'number' },
@@ -391,7 +391,7 @@ const lag = {
         impl: { function: 'LAG', needsWindowOrderBy: true },
     },
     'with_default': {
-        generic: ['T', LAG_TYPES],
+        generic: { 'T': LAG_TYPES },
         takes: {
             'value': { measure: { generic: 'T' } },
             'offset': { literal: 'number' },
@@ -402,7 +402,7 @@ const lag = {
     },
 };
 const last_value = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date', 'json'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: {
@@ -426,25 +426,25 @@ const lead = {
     },
 };
 const max_cumulative = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'MAX', needsWindowOrderBy: true },
 };
 const max_window = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'MAX', needsWindowOrderBy: false },
 };
 const min_cumulative = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'MIN', needsWindowOrderBy: true },
 };
 const min_window = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'MIN', needsWindowOrderBy: false },
@@ -461,14 +461,14 @@ const row_number = {
     impl: { function: 'ROW_NUMBER', needsWindowOrderBy: true },
 };
 const sum_cumulative = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'SUM', needsWindowOrderBy: true },
 };
 const sum_moving = {
     'preceding': {
-        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
         takes: {
             'value': { measure: { generic: 'T' } },
             'preceding': { literal: 'number' },
@@ -481,7 +481,7 @@ const sum_moving = {
         },
     },
     'following': {
-        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
         takes: {
             'value': { measure: { generic: 'T' } },
             'preceding': { literal: 'number' },
@@ -496,7 +496,7 @@ const sum_moving = {
     },
 };
 const sum_window = {
-    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    generic: { 'T': ['string', 'number', 'timestamp', 'date'] },
     takes: { 'value': { measure: { generic: 'T' } } },
     returns: { calculation: { generic: 'T' } },
     impl: { function: 'SUM', needsWindowOrderBy: false },

package/dist/dialect/functions/util.d.ts

@@ -1,8 +1,12 @@
-import { FunctionParameterDef, TypeDesc, Expr, FunctionParamTypeDesc, LeafExpressionType } from '../../model/malloy_types';
+import { FunctionParameterDef, TypeDesc, Expr, FunctionParamTypeDesc, LeafExpressionType, FunctionReturnTypeDesc, FunctionParameterTypeDef, ExpressionType, EvalSpace, FunctionGenericTypeDef } from '../../model/malloy_types';
 import { SQLExprElement } from '../../model/utils';
 export interface DialectFunctionOverloadDef {
-    returnType: TypeDesc;
+    returnType: FunctionReturnTypeDesc;
     params: FunctionParameterDef[];
+    genericTypes?: {
+        name: string;
+        acceptibleTypes: FunctionGenericTypeDef[];
+    }[];
     e: Expr;
     needsWindowOrderBy?: boolean;
     isSymmetric?: boolean;
@@ -17,9 +21,15 @@ export interface DialectFunctionOverloadDef {
 export declare function arg(name: string): Expr;
 export declare function spread(e: Expr, prefix?: string | undefined, suffix?: string | undefined): Expr;
 export declare function sql(strings: TemplateStringsArray, ...subExprs: SQLExprElement[]): Expr;
-export declare function constant(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
-export declare function output(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
-export declare function literal(type: FunctionParamTypeDesc): FunctionParamTypeDesc;
+export declare function constant<T extends {
+    expressionType: ExpressionType | undefined;
+}>(type: T): T & TypeDescExtras;
+export declare function output<T extends {
+    expressionType: ExpressionType | undefined;
+}>(type: T): T & TypeDescExtras;
+export declare function literal<T extends {
+    expressionType: ExpressionType | undefined;
+}>(type: T): T & TypeDescExtras;
 export declare function variadicParam(name: string, ...allowedTypes: FunctionParamTypeDesc[]): FunctionParameterDef;
 /**
  * Prefer `makeParam` for future function definitions
@@ -29,14 +39,18 @@ export declare function makeParam(name: string, ...allowedTypes: FunctionParamTy
     param: FunctionParameterDef;
     arg: Expr;
 };
-export declare function maxScalar(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function maxAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function anyExprType(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function maxUngroupedAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function maxAnalytic(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function minScalar(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function minAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
-export declare function minAnalytic(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function maxScalar<T>(type: T): T & TypeDescExtras;
+export declare function maxAggregate<T>(type: T): T & TypeDescExtras;
+export declare function anyExprType<T>(type: T): T & TypeDescExtras;
+export declare function maxUngroupedAggregate(type: FunctionParameterTypeDef): FunctionParamTypeDesc;
+type TypeDescExtras = {
+    expressionType: ExpressionType | undefined;
+    evalSpace: EvalSpace;
+};
+export declare function maxAnalytic<T>(type: T): T & TypeDescExtras;
+export declare function minScalar<T>(type: T): T & TypeDescExtras;
+export declare function minAggregate<T>(type: T): T & TypeDescExtras;
+export declare function minAnalytic<T>(type: T): T & TypeDescExtras;
 export declare function overload(returnType: TypeDesc, params: FunctionParameterDef[], e: Expr, options?: {
     needsWindowOrderBy?: boolean;
     between?: {
@@ -49,40 +63,38 @@ export declare function overload(returnType: TypeDesc, params: FunctionParameter
     supportsOrderBy?: boolean | 'only_default';
 }): DialectFunctionOverloadDef;
 export interface ArrayBlueprint {
-    array: TypeDescElementBlueprint;
+    array: TypeDescElementBlueprintOrNamedGeneric;
 }
+export type TypeDescElementBlueprintOrNamedGeneric = TypeDescElementBlueprint | NamedGeneric;
 export interface RecordBlueprint {
-    record: Record<string, TypeDescElementBlueprint>;
+    record: Record<string, TypeDescElementBlueprintOrNamedGeneric>;
+}
+export interface SQLNativeTypeBlueprint {
+    sql_native: string;
 }
-export type TypeDescElementBlueprint = LeafExpressionType | ArrayBlueprint | RecordBlueprint;
-export type TypeDescBlueprint = TypeDescElementBlueprint | {
+export type LeafPlusType = LeafExpressionType | 'any';
+export type TypeDescElementBlueprint = LeafPlusType | ArrayBlueprint | RecordBlueprint | SQLNativeTypeBlueprint;
+export type NamedGeneric = {
     generic: string;
+};
+export type TypeDescBlueprint = TypeDescElementBlueprintOrNamedGeneric | {
+    literal: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    literal: LeafExpressionType | {
-        generic: string;
-    };
-} | {
-    constant: LeafExpressionType | {
-        generic: string;
-    };
+    constant: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    dimension: LeafExpressionType | {
-        generic: string;
-    };
+    dimension: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    measure: LeafExpressionType | {
-        generic: string;
-    };
+    measure: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    calculation: LeafExpressionType | {
-        generic: string;
-    };
+    calculation: TypeDescElementBlueprintOrNamedGeneric;
 };
 type ParamTypeBlueprint = TypeDescBlueprint | TypeDescBlueprint[] | {
     variadic: TypeDescBlueprint | TypeDescBlueprint[];
 };
 export interface SignatureBlueprint {
-    generic?: [string, LeafExpressionType[]];
+    generic?: {
+        [name: string]: TypeDescElementBlueprintOrNamedGeneric[];
+    };
     takes: {
         [name: string]: ParamTypeBlueprint;
     };

package/dist/dialect/functions/util.js

@@ -1,6 +1,7 @@
 "use strict";
 /*
  * Copyright 2023 Google LLC
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
@@ -23,7 +24,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandOverrideMapFromBase = exports.expandBlueprintMap = exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.variadicParam = exports.literal = exports.output = exports.constant = exports.sql = exports.spread = exports.arg = void 0;
-const composite_source_utils_1 = require("../../model/composite_source_utils");
 const malloy_types_1 = require("../../model/malloy_types");
 function arg(name) {
     return { node: 'function_parameter', name };
@@ -106,39 +106,35 @@ function makeParam(name, ...allowedTypes) {
 }
 exports.makeParam = makeParam;
 function maxScalar(type) {
-    return { type, expressionType: 'scalar', evalSpace: 'input' };
+    return { ...type, expressionType: 'scalar', evalSpace: 'input' };
 }
 exports.maxScalar = maxScalar;
 function maxAggregate(type) {
-    return { type, expressionType: 'aggregate', evalSpace: 'input' };
+    return { ...type, expressionType: 'aggregate', evalSpace: 'input' };
 }
 exports.maxAggregate = maxAggregate;
 function anyExprType(type) {
-    return { type, expressionType: undefined, evalSpace: 'input' };
+    return { ...type, expressionType: undefined, evalSpace: 'input' };
 }
 exports.anyExprType = anyExprType;
-function anyExprTypeBP(type, generic) {
-    const typeDesc = expandReturnTypeBlueprint(type, generic);
-    return { ...typeDesc, expressionType: undefined, evalSpace: 'input' };
-}
 function maxUngroupedAggregate(type) {
-    return { type, expressionType: 'ungrouped_aggregate', evalSpace: 'input' };
+    return { ...type, expressionType: 'ungrouped_aggregate', evalSpace: 'input' };
 }
 exports.maxUngroupedAggregate = maxUngroupedAggregate;
 function maxAnalytic(type) {
-    return { type, expressionType: 'aggregate_analytic', evalSpace: 'input' };
+    return { ...type, expressionType: 'aggregate_analytic', evalSpace: 'input' };
 }
 exports.maxAnalytic = maxAnalytic;
 function minScalar(type) {
-    return { type, expressionType: 'scalar', evalSpace: 'input' };
+    return { ...type, expressionType: 'scalar', evalSpace: 'input' };
 }
 exports.minScalar = minScalar;
 function minAggregate(type) {
-    return { type, expressionType: 'aggregate', evalSpace: 'input' };
+    return { ...type, expressionType: 'aggregate', evalSpace: 'input' };
 }
 exports.minAggregate = minAggregate;
 function minAnalytic(type) {
-    return { type, expressionType: 'scalar_analytic', evalSpace: 'input' };
+    return { ...type, expressionType: 'scalar_analytic', evalSpace: 'input' };
 }
 exports.minAnalytic = minAnalytic;
 function overload(returnType, params, e, options) {
@@ -155,86 +151,89 @@ function overload(returnType, params, e, options) {
     };
 }
 exports.overload = overload;
-function removeGeneric(type, generic) {
-    if (typeof type === 'string') {
-        return type;
-    }
-    if (type.generic !== (generic === null || generic === void 0 ? void 0 : generic.name)) {
-        throw new Error(`Cannot expand generic name ${type.generic}`);
+function expandTypeDescElementBlueprint(blueprint, allowAny = true, allowGenerics = true) {
+    if (!allowAny && blueprint === 'any') {
+        throw new Error('Return type cannot include any');
     }
-    return generic.type;
-}
-function expandReturnTypeBlueprint(blueprint, generic) {
-    var _a;
-    let base;
     if (typeof blueprint === 'string') {
-        base = minScalar(blueprint);
+        return { type: blueprint };
     }
     else if ('array' in blueprint) {
-        const innerType = expandReturnTypeBlueprint(blueprint.array, generic);
-        const { expressionType, evalSpace } = innerType;
-        if (malloy_types_1.TD.isAtomic(innerType)) {
-            if (innerType.type !== 'record') {
-                base = {
-                    type: 'array',
-                    elementTypeDef: innerType,
-                    expressionType,
-                    evalSpace,
-                };
-            }
-            else {
-                base = {
-                    type: 'array',
-                    elementTypeDef: { type: 'record_element' },
-                    fields: innerType.fields,
-                    expressionType,
-                    evalSpace,
-                };
-            }
-        }
-        else {
-            // mtoy todo  fix by doing "exapndElementBlueprint" ...
-            throw new Error(`TypeDescElementBlueprint should never allow ${blueprint.array}`);
+        const innerType = allowAny
+            ? expandTypeDescElementBlueprint(blueprint.array, true)
+            : expandTypeDescElementBlueprint(blueprint.array, false);
+        if (innerType.type === 'record') {
+            return {
+                type: 'array',
+                elementTypeDef: { type: 'record_element' },
+                fields: innerType.fields,
+            };
         }
+        return {
+            type: 'array',
+            elementTypeDef: innerType,
+        };
     }
     else if ('record' in blueprint) {
         const fields = [];
         for (const [fieldName, fieldBlueprint] of Object.entries(blueprint.record)) {
-            const fieldDesc = expandReturnTypeBlueprint(fieldBlueprint, generic);
+            const fieldDesc = allowAny
+                ? expandTypeDescElementBlueprint(fieldBlueprint, true)
+                : expandTypeDescElementBlueprint(fieldBlueprint, false);
             if (malloy_types_1.TD.isAtomic(fieldDesc)) {
                 fields.push((0, malloy_types_1.mkFieldDef)(fieldDesc, fieldName));
             }
         }
-        base = {
+        return {
             type: 'record',
             fields,
-            evalSpace: 'input',
-            expressionType: 'scalar',
         };
     }
     else if ('generic' in blueprint) {
-        base = minScalar(removeGeneric(blueprint, generic));
+        if (!allowGenerics) {
+            throw new Error('Cannot use generic');
+        }
+        return { type: 'generic', generic: blueprint.generic };
+    }
+    else if ('sql_native' in blueprint) {
+        return { type: 'sql native', rawType: blueprint.sql_native };
+    }
+    throw new Error('Cannot figure out type');
+}
+function expandReturnTypeBlueprint(blueprint) {
+    if (blueprint === 'any') {
+        throw new Error('Cannot return any type');
+    }
+    if (typeof blueprint === 'string') {
+        return minScalar({ type: blueprint });
+    }
+    else if ('array' in blueprint) {
+        return anyExprType(expandTypeDescElementBlueprint(blueprint, false));
+    }
+    else if ('record' in blueprint) {
+        return anyExprType(expandTypeDescElementBlueprint(blueprint, false));
+    }
+    else if ('generic' in blueprint) {
+        return minScalar(expandTypeDescElementBlueprint(blueprint, false));
     }
     else if ('literal' in blueprint) {
-        base = literal(minScalar(removeGeneric(blueprint.literal, generic)));
+        return literal(minScalar(expandTypeDescElementBlueprint(blueprint.literal, false)));
     }
     else if ('constant' in blueprint) {
-        base = constant(minScalar(removeGeneric(blueprint.constant, generic)));
+        return constant(minScalar(expandTypeDescElementBlueprint(blueprint.constant, false)));
     }
     else if ('dimension' in blueprint) {
-        base = minScalar(removeGeneric(blueprint.dimension, generic));
+        return minScalar(expandTypeDescElementBlueprint(blueprint.dimension, false));
     }
     else if ('measure' in blueprint) {
-        base = minAggregate(removeGeneric(blueprint.measure, generic));
+        return minAggregate(expandTypeDescElementBlueprint(blueprint.measure, false));
+    }
+    else if ('sql_native' in blueprint) {
+        return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
     else {
-        base = minAnalytic(removeGeneric(blueprint.calculation, generic));
+        return minAnalytic(expandTypeDescElementBlueprint(blueprint.calculation, false));
     }
-    return {
-        ...base,
-        compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
-        expressionType: (_a = base.expressionType) !== null && _a !== void 0 ? _a : 'scalar',
-    };
 }
 function isTypeDescBlueprint(blueprint) {
     return (typeof blueprint === 'string' ||
@@ -245,7 +244,8 @@ function isTypeDescBlueprint(blueprint) {
         'constant' in blueprint ||
         'dimension' in blueprint ||
         'measure' in blueprint ||
-        'calculation' in blueprint);
+        'calculation' in blueprint ||
+        'sql_native' in blueprint);
 }
 function extractParamTypeBlueprints(blueprint) {
     if (isTypeDescBlueprint(blueprint)) {
@@ -261,51 +261,54 @@ function extractParamTypeBlueprints(blueprint) {
         return blueprint.variadic;
     }
 }
-function expandParamTypeBlueprint(blueprint, generic) {
+function expandParamTypeBlueprint(blueprint) {
     if (typeof blueprint === 'string') {
-        return anyExprType(blueprint);
+        return anyExprType({ type: blueprint });
     }
     else if ('generic' in blueprint) {
-        return anyExprType(removeGeneric(blueprint, generic));
+        return anyExprType(expandTypeDescElementBlueprint(blueprint));
     }
     else if ('literal' in blueprint) {
-        return literal(maxScalar(removeGeneric(blueprint.literal, generic)));
+        return literal(maxScalar(expandTypeDescElementBlueprint(blueprint.literal)));
     }
     else if ('constant' in blueprint) {
-        return constant(maxScalar(removeGeneric(blueprint.constant, generic)));
+        return constant(maxScalar(expandTypeDescElementBlueprint(blueprint.constant)));
     }
     else if ('dimension' in blueprint) {
-        return maxScalar(removeGeneric(blueprint.dimension, generic));
+        return maxScalar(expandTypeDescElementBlueprint(blueprint.dimension));
     }
     else if ('measure' in blueprint) {
-        return maxAggregate(removeGeneric(blueprint.measure, generic));
+        return maxAggregate(expandTypeDescElementBlueprint(blueprint.measure));
     }
     else if ('array' in blueprint) {
-        return anyExprTypeBP(blueprint, generic);
+        return anyExprType(expandTypeDescElementBlueprint(blueprint, false));
     }
     else if ('record' in blueprint) {
-        return anyExprTypeBP(blueprint, generic);
+        return anyExprType(expandTypeDescElementBlueprint(blueprint, false));
+    }
+    else if ('sql_native' in blueprint) {
+        return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
     else {
-        return maxAnalytic(removeGeneric(blueprint.calculation, generic));
+        return maxAnalytic(expandTypeDescElementBlueprint(blueprint.calculation));
     }
 }
-function expandParamTypeBlueprints(blueprints, generic) {
-    return blueprints.map(blueprint => expandParamTypeBlueprint(blueprint, generic));
+function expandParamTypeBlueprints(blueprints) {
+    return blueprints.map(blueprint => expandParamTypeBlueprint(blueprint));
 }
 function isVariadicParamBlueprint(blueprint) {
     return typeof blueprint !== 'string' && 'variadic' in blueprint;
 }
-function expandParamBlueprint(name, blueprint, generic) {
+function expandParamBlueprint(name, blueprint) {
     return {
         name,
-        allowedTypes: expandParamTypeBlueprints(extractParamTypeBlueprints(blueprint), generic),
+        allowedTypes: expandParamTypeBlueprints(extractParamTypeBlueprints(blueprint)),
         isVariadic: isVariadicParamBlueprint(blueprint),
     };
 }
-function expandParamsBlueprints(blueprints, generic) {
+function expandParamsBlueprints(blueprints) {
     const paramsArray = Object.entries(blueprints);
-    return paramsArray.map(blueprint => expandParamBlueprint(blueprint[0], blueprint[1], generic));
+    return paramsArray.map(blueprint => expandParamBlueprint(blueprint[0], blueprint[1]));
 }
 function expandBlueprintSqlInterpolation(sql) {
     const src = [];
@@ -393,23 +396,25 @@ function expandImplBlueprint(blueprint) {
         defaultOrderByArgIndex: blueprint.impl.defaultOrderByArgIndex,
     };
 }
-function expandOneBlueprint(blueprint, generic) {
+function expandGenericDefinitions(blueprint) {
+    if (blueprint === undefined)
+        return undefined;
+    return Object.entries(blueprint).map(([name, acceptibleTypes]) => ({
+        name: name,
+        acceptibleTypes: acceptibleTypes.map(t => expandTypeDescElementBlueprint(t, true, false)),
+    }));
+}
+function expandBlueprint(blueprint) {
     return {
-        returnType: expandReturnTypeBlueprint(blueprint.returns, generic),
-        params: expandParamsBlueprints(blueprint.takes, generic),
+        returnType: expandReturnTypeBlueprint(blueprint.returns),
+        params: expandParamsBlueprints(blueprint.takes),
         isSymmetric: blueprint.isSymmetric,
         supportsOrderBy: blueprint.supportsOrderBy,
         supportsLimit: blueprint.supportsLimit,
+        genericTypes: expandGenericDefinitions(blueprint.generic),
         ...expandImplBlueprint(blueprint),
     };
 }
-function expandBlueprint(blueprint) {
-    if (blueprint.generic !== undefined) {
-        const name = blueprint.generic[0];
-        return blueprint.generic[1].map(type => expandOneBlueprint(blueprint, { name, type }));
-    }
-    return [expandOneBlueprint(blueprint)];
-}
 function isDefinitionBlueprint(blueprint) {
     return 'takes' in blueprint && 'returns' in blueprint && 'impl' in blueprint;
 }
@@ -418,7 +423,7 @@ function isImplementationBlueprint(blueprint) {
 }
 function expandOverloadedBlueprint(blueprint) {
     if (isDefinitionBlueprint(blueprint)) {
-        return expandBlueprint(blueprint);
+        return [expandBlueprint(blueprint)];
     }
     else {
         return Object.values(blueprint).flatMap(overload => expandBlueprint(overload));
@@ -433,7 +438,7 @@ function expandBlueprintMap(blueprints) {
 }
 exports.expandBlueprintMap = expandBlueprintMap;
 function expandImplementationBlueprint(base, impl) {
-    return expandBlueprint({ ...base, impl });
+    return [expandBlueprint({ ...base, impl })];
 }
 function expandOverloadedOverrideBlueprint(name, base, blueprint) {
     if (isImplementationBlueprint(blueprint)) {

package/dist/dialect/trino/dialect_functions.js

@@ -20,7 +20,7 @@ const approx_percentile = {
     },
 };
 const arbitrary = {
-    generic: ['T', ['string', 'number', 'date', 'timestamp', 'boolean', 'json']],
+    generic: { 'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'] },
     takes: { 'value': { dimension: { generic: 'T' } } },
     returns: { measure: { generic: 'T' } },
     impl: { function: 'ARBITRARY' },
@@ -64,7 +64,7 @@ const count_approx = {
     isSymmetric: true,
 };
 const max_by = {
-    generic: ['T', ['string', 'number', 'date', 'timestamp', 'boolean', 'json']],
+    generic: { 'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'] },
     takes: {
         'value': { dimension: { generic: 'T' } },
         'order_by_val': { dimension: 'any' },
@@ -74,7 +74,7 @@ const max_by = {
     isSymmetric: true,
 };
 const min_by = {
-    generic: ['T', ['string', 'number', 'date', 'timestamp', 'boolean', 'json']],
+    generic: { 'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'] },
     takes: {
         'value': { dimension: { generic: 'T' } },
         'order_by_val': { dimension: 'any' },

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

@@ -101,7 +101,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         return { found: func, error: undefined };
     }
     getPropsExpression(fs, props) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
         if (this.isRaw) {
             const funcCall = [`${this.name}(`];
@@ -167,7 +167,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 .map(e => e.type)
                 .join(', ')})`);
         }
-        const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
+        const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors, returnType, } = result;
         // Report errors for expression type mismatch
         for (const error of expressionTypeErrors) {
             const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
@@ -194,9 +194,13 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             const arg = this.args[adjustedIndex];
             arg.logError('literal-null-function-argument', `Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must not be a literal null`);
         }
+        // Report return type error
+        if (result.returnTypeError) {
+            this.logError(result.returnTypeError.code, result.returnTypeError.parameters);
+        }
         const type = overload.returnType;
         const expressionType = (0, malloy_types_1.maxOfExpressionTypes)([
-            type.expressionType,
+            (_d = type.expressionType) !== null && _d !== void 0 ? _d : 'scalar',
             ...argExprs.map(e => e.expressionType),
         ]);
         if (!(0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
@@ -316,9 +320,6 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 funcCall = (0, utils_1.composeSQLExpr)(expr);
             }
         }
-        if (type.type === 'any') {
-            return this.loggedErrorExpr('function-returns-any', `Invalid return type ${type.type} for function '${this.name}'`);
-        }
         const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
         // If the merged eval space of all args is constant, the result is constant.
         // If the expression is scalar, then the eval space is that merged eval space.
@@ -333,7 +334,8 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         // TODO consider if I can use `computedExprValue` here...
         // seems like the rules for the evalSpace is a bit different from normal though
         return {
-            ...TDU.atomicDef(type),
+            // TODO need to handle this???
+            ...((0, malloy_types_1.isAtomic)(returnType) ? TDU.atomicDef(returnType) : returnType),
             expressionType,
             value: funcCall,
             evalSpace,
@@ -343,7 +345,10 @@ class ExprFunc extends expression_def_1.ExpressionDef {
 }
 exports.ExprFunc = ExprFunc;
 function findOverload(func, args) {
+    var _a;
     for (const overload of func.overloads) {
+        // Map from generic name to selected type
+        const genericsSelected = new Map();
         let paramIndex = 0;
         let ok = true;
         let matchedVariadic = false;
@@ -358,15 +363,13 @@ function findOverload(func, args) {
                 break;
             }
             const argOk = param.allowedTypes.some(paramT => {
+                var _a;
                 // Check whether types match (allowing for nullability errors, expression type errors,
                 // eval space errors, and unknown types due to prior errors in args)
-                const dataTypeMatch = malloy_types_1.TD.eq(paramT, arg) ||
-                    paramT.type === 'any' ||
-                    // TODO We should consider whether `nulls` should always be allowed. It probably
-                    // does not make sense to limit function calls to not allow nulls, since have
-                    // so little control over nullability.
-                    arg.type === 'null' ||
-                    arg.type === 'error';
+                const { dataTypeMatch, genericsSet } = isDataTypeMatch(genericsSelected, (_a = overload.genericTypes) !== null && _a !== void 0 ? _a : [], arg, paramT);
+                for (const genericSet of genericsSet) {
+                    genericsSelected.set(genericSet.name, genericSet.type);
+                }
                 // Check expression type errors
                 if (paramT.expressionType) {
                     const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);
@@ -425,12 +428,16 @@ function findOverload(func, args) {
             (paramIndex !== args.length || paramIndex !== overload.params.length)) {
             continue;
         }
+        const resolveReturnType = resolveGenerics(overload.returnType, genericsSelected);
+        const returnType = (_a = resolveReturnType.returnType) !== null && _a !== void 0 ? _a : { type: 'number' };
         if (ok) {
             return {
                 overload,
                 expressionTypeErrors,
                 evalSpaceErrors,
                 nullabilityErrors,
+                returnTypeError: resolveReturnType.error,
+                returnType,
             };
         }
     }
@@ -462,4 +469,163 @@ function parseSQLInterpolation(template) {
     }
     return parts;
 }
+function isDataTypeMatch(genericsAlreadySelected, genericTypes, arg, paramT) {
+    var _a, _b, _c, _d;
+    if (malloy_types_1.TD.eq(paramT, arg) ||
+        paramT.type === 'any' ||
+        // TODO We should consider whether `nulls` should always be allowed. It probably
+        // does not make sense to limit function calls to not allow nulls, since have
+        // so little control over nullability.
+        (paramT.type !== 'generic' && (arg.type === 'null' || arg.type === 'error'))) {
+        return { dataTypeMatch: true, genericsSet: [] };
+    }
+    if (paramT.type === 'array' && arg.type === 'array') {
+        if ((0, malloy_types_1.isScalarArray)(arg)) {
+            if (!(0, malloy_types_1.isRepeatedRecordFunctionParam)(paramT)) {
+                return isDataTypeMatch(genericsAlreadySelected, genericTypes, arg.elementTypeDef, paramT.elementTypeDef);
+            }
+            else {
+                return { dataTypeMatch: false, genericsSet: [] };
+            }
+        }
+        else if ((0, malloy_types_1.isRepeatedRecordFunctionParam)(paramT)) {
+            const fakeParamRecord = {
+                type: 'record',
+                fields: paramT.fields,
+            };
+            const fakeArgRecord = {
+                type: 'record',
+                fields: arg.fields,
+            };
+            return isDataTypeMatch(genericsAlreadySelected, genericTypes, fakeArgRecord, fakeParamRecord);
+        }
+        else {
+            return { dataTypeMatch: false, genericsSet: [] };
+        }
+    }
+    else if (paramT.type === 'record' && arg.type === 'record') {
+        const genericsSet = [];
+        const paramFieldsByName = new Map();
+        for (const field of paramT.fields) {
+            paramFieldsByName.set((_a = field.as) !== null && _a !== void 0 ? _a : field.name, field);
+        }
+        for (const field of arg.fields) {
+            const match = paramFieldsByName.get((_b = field.as) !== null && _b !== void 0 ? _b : field.name);
+            if (match === undefined) {
+                return { dataTypeMatch: false, genericsSet: [] };
+            }
+            const result = isDataTypeMatch(new Map([
+                ...genericsAlreadySelected.entries(),
+                ...genericsSet.map(x => [x.name, x.type]),
+            ]), genericTypes, field, match);
+            genericsSet.push(...result.genericsSet);
+        }
+        return { dataTypeMatch: true, genericsSet };
+    }
+    else if (paramT.type === 'generic') {
+        const alreadySelected = genericsAlreadySelected.get(paramT.generic);
+        if (alreadySelected !== undefined &&
+            alreadySelected.type !== 'null' &&
+            alreadySelected.type !== 'error') {
+            return isDataTypeMatch(genericsAlreadySelected, genericTypes, arg, alreadySelected);
+        }
+        const allowedTypes = (_d = (_c = genericTypes.find(t => t.name === paramT.generic)) === null || _c === void 0 ? void 0 : _c.acceptibleTypes) !== null && _d !== void 0 ? _d : [];
+        for (const type of allowedTypes) {
+            const result = isDataTypeMatch(genericsAlreadySelected, genericTypes, arg, type);
+            if (result.dataTypeMatch) {
+                if (!(0, malloy_types_1.isAtomic)(arg) && arg.type !== 'null') {
+                    continue;
+                }
+                const newGenericSet = {
+                    name: paramT.generic,
+                    type: arg,
+                };
+                return {
+                    dataTypeMatch: true,
+                    genericsSet: [...result.genericsSet, newGenericSet],
+                };
+            }
+        }
+    }
+    return { dataTypeMatch: false, genericsSet: [] };
+}
+function resolveGenerics(returnType, genericsSelected) {
+    switch (returnType.type) {
+        case 'array': {
+            if ('fields' in returnType) {
+                const fields = returnType.fields.map(f => {
+                    const type = resolveGenerics(f, genericsSelected);
+                    return {
+                        ...f,
+                        ...type,
+                    };
+                });
+                return {
+                    error: undefined,
+                    returnType: {
+                        type: 'array',
+                        elementTypeDef: returnType.elementTypeDef,
+                        fields,
+                    },
+                };
+            }
+            const resolve = resolveGenerics(returnType.elementTypeDef, genericsSelected);
+            if (resolve.error) {
+                return resolve;
+            }
+            const elementTypeDef = resolve.returnType;
+            if (elementTypeDef.type === 'record') {
+                return {
+                    error: undefined,
+                    returnType: {
+                        type: 'array',
+                        elementTypeDef: { type: 'record_element' },
+                        fields: elementTypeDef.fields,
+                    },
+                };
+            }
+            if (!(0, malloy_types_1.isAtomic)(elementTypeDef)) {
+                return {
+                    error: {
+                        code: 'invalid-resolved-type-for-array',
+                        parameters: 'Invalid resolved type for array; cannot be non-atomic',
+                    },
+                    returnType: undefined,
+                };
+            }
+            return {
+                error: undefined,
+                returnType: { type: 'array', elementTypeDef },
+            };
+        }
+        case 'record': {
+            const fields = returnType.fields.map(f => {
+                const type = resolveGenerics(f, genericsSelected);
+                return {
+                    ...f,
+                    ...type,
+                };
+            });
+            return { error: undefined, returnType: { type: 'record', fields } };
+        }
+        case 'generic': {
+            const resolved = genericsSelected.get(returnType.generic);
+            if (resolved === undefined) {
+                return {
+                    error: {
+                        code: 'generic-not-resolved',
+                        parameters: `Generic ${returnType.generic} in return type could not be resolved`,
+                    },
+                    returnType: undefined,
+                };
+            }
+            return {
+                error: undefined,
+                returnType: resolved,
+            };
+        }
+        default:
+            return { error: undefined, returnType };
+    }
+}
 //# sourceMappingURL=expr-func.js.map

package/dist/lang/ast/types/dialect-name-space.js

@@ -26,6 +26,7 @@ class DialectNameSpace {
                         supportsOrderBy: overload.supportsOrderBy,
                         supportsLimit: overload.supportsLimit,
                         isSymmetric: overload.isSymmetric,
+                        genericTypes: overload.genericTypes,
                         dialect: {
                             [dialect.name]: {
                                 e: overload.e,

package/dist/lang/ast/types/global-name-space.js

@@ -82,6 +82,7 @@ function getDialectFunctions() {
                 dialect: {},
                 supportsOrderBy: baseOverload.supportsOrderBy,
                 supportsLimit: baseOverload.supportsLimit,
+                genericTypes: baseOverload.genericTypes,
                 isSymmetric: baseOverload.isSymmetric,
             };
             for (const dialect of dialects) {

package/dist/lang/parse-log.d.ts

@@ -357,6 +357,8 @@ type MessageParameterTypes = {
     'exclude-after-include': string;
     'cannot-rename-non-field': string;
     'array-values-incompatible': string;
+    'invalid-resolved-type-for-array': string;
+    'generic-not-resolved': string;
     'cannot-tag-include-except': string;
     'unsupported-path-in-include': string;
     'wildcard-include-rename': string;
@@ -364,6 +366,11 @@ type MessageParameterTypes = {
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
 export type MessageCode = keyof MessageParameterTypes;
 export type MessageParameterType<T extends MessageCode> = MessageParameterTypes[T];
+type MessageCodeAndParameters<T extends MessageCode> = {
+    code: T;
+    parameters: MessageParameterType<T>;
+};
+export type AnyMessageCodeAndParameters = MessageCodeAndParameters<MessageCode>;
 type MessageFormatter<T extends MessageCode> = MessageInfo | ((parameters: MessageParameterType<T>) => MessageInfo);
 type ErrorCodeMessageMap = {
     [key in keyof MessageParameterTypes]: MessageFormatter<key>;

package/dist/model/malloy_types.d.ts

@@ -414,6 +414,7 @@ export interface RepeatedRecordDef extends RepeatedRecordTypeDef, StructDefBase,
 }
 export type ArrayTypeDef = ScalarArrayTypeDef | RepeatedRecordTypeDef;
 export type ArrayDef = ScalarArrayDef | RepeatedRecordDef;
+export declare function isRepeatedRecordFunctionParam(paramT: FunctionParameterTypeDef): paramT is RepeatedRecordFunctionParameterTypeDef;
 export declare function isRepeatedRecord(fd: FieldDef | QueryFieldDef | StructDef | AtomicTypeDef): fd is RepeatedRecordTypeDef;
 export declare function isScalarArray(td: AtomicTypeDef | FieldDef | QueryFieldDef | StructDef): td is ScalarArrayTypeDef;
 export interface ErrorTypeDef {
@@ -630,7 +631,7 @@ export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryRe
 /** Is this the "FROM" table of a query tree */
 export declare function isBaseTable(def: StructDef): def is SourceDef;
 export type StructDef = SourceDef | RecordDef | ArrayDef;
-export type NonAtomicType = Exclude<JoinElementType, 'array' | 'record'> | 'turtle' | 'null' | 'duration' | 'any' | 'regular expression';
+export type NonAtomicType = Exclude<JoinElementType, 'array' | 'record'> | 'turtle' | 'null' | 'duration' | 'regular expression';
 export interface NonAtomicTypeDef {
     type: NonAtomicType;
 }
@@ -643,13 +644,54 @@ export type TypeInfo = {
     compositeFieldUsage: CompositeFieldUsage;
 };
 export type TypeDesc = ExpressionValueTypeDef & TypeInfo;
-export type FunctionParamType = ExpressionValueTypeDef | {
-    type: 'any';
+export type FunctionParameterTypeDef = ExpressionValueExtTypeDef<FunctionParameterTypeExtensions>;
+export type FunctionParamTypeDesc = FunctionParameterTypeDef & {
+    expressionType: ExpressionType | undefined;
+    evalSpace: EvalSpace;
 };
-export type FunctionParamTypeDesc = FunctionParamType & {
+interface ScalarArrayExtTypeDef<TypeExtensions> {
+    type: 'array';
+    elementTypeDef: Exclude<ExpressionValueExtTypeDef<TypeExtensions>, RecordExtTypeDef<TypeExtensions>>;
+}
+type ExpressionValueExtTypeDef<TypeExtensions> = AtomicTypeDef | NonAtomicTypeDef | ScalarArrayExtTypeDef<TypeExtensions> | RecordExtTypeDef<TypeExtensions> | RepeatedRecordExtTypeDef<TypeExtensions> | TypeExtensions;
+interface RecordExtTypeDef<TypeExtensions> {
+    type: 'record';
+    fields: ExtFieldDef<TypeExtensions>[];
+}
+type ExtFieldDef<TypeExtensions> = FieldDef | (TypeExtensions & FieldBase);
+interface RepeatedRecordExtTypeDef<TypeExtensions> {
+    type: 'array';
+    elementTypeDef: RecordElementTypeDef;
+    fields: ExtFieldDef<TypeExtensions>[];
+}
+type FunctionReturnTypeExtensions = GenericTypeDef;
+export type ScalarArrayFunctionReturnTypeDef = ScalarArrayExtTypeDef<FunctionReturnTypeExtensions>;
+export type FunctionReturnFieldDef = ExtFieldDef<FunctionReturnTypeExtensions>;
+export type RecordFunctionReturnTypeDef = RecordExtTypeDef<FunctionReturnTypeExtensions>;
+export type RepeatedRecordFunctionReturnTypeDef = RepeatedRecordExtTypeDef<FunctionReturnTypeExtensions>;
+type FunctionParameterTypeExtensions = GenericTypeDef | AnyTypeDef;
+export type ScalarArrayFunctionParameterTypeDef = ScalarArrayExtTypeDef<FunctionParameterTypeExtensions>;
+export type FunctionParameterFieldDef = ExtFieldDef<FunctionParameterTypeExtensions>;
+export type RecordFunctionParameterTypeDef = RecordExtTypeDef<FunctionParameterTypeExtensions>;
+export type RepeatedRecordFunctionParameterTypeDef = RepeatedRecordExtTypeDef<FunctionParameterTypeExtensions>;
+type FunctionGenericTypeExtensions = AnyTypeDef;
+export type ScalarArrayFunctionGenericTypeDef = ScalarArrayExtTypeDef<FunctionGenericTypeExtensions>;
+export type FunctionGenericFieldDef = ExtFieldDef<FunctionGenericTypeExtensions>;
+export type RecordFunctionGenericTypeDef = RecordExtTypeDef<FunctionGenericTypeExtensions>;
+export type RepeatedRecordFunctionGenericTypeDef = RepeatedRecordExtTypeDef<FunctionGenericTypeExtensions>;
+export interface GenericTypeDef {
+    type: 'generic';
+    generic: string;
+}
+export interface AnyTypeDef {
+    type: 'any';
+}
+export type TypeDescExtensions = {
     expressionType: ExpressionType | undefined;
     evalSpace: EvalSpace;
 };
+export type FunctionReturnTypeDef = ExpressionValueExtTypeDef<FunctionReturnTypeExtensions>;
+export type FunctionReturnTypeDesc = FunctionReturnTypeDef & TypeDescExtensions;
 export type EvalSpace = 'constant' | 'input' | 'output' | 'literal';
 export declare function isLiteral(evalSpace: EvalSpace): boolean;
 export declare function mergeEvalSpaces(...evalSpaces: EvalSpace[]): EvalSpace;
@@ -658,12 +700,17 @@ export interface FunctionParameterDef {
     allowedTypes: FunctionParamTypeDesc[];
     isVariadic: boolean;
 }
+export type FunctionGenericTypeDef = ExpressionValueExtTypeDef<FunctionGenericTypeExtensions>;
 export interface FunctionOverloadDef {
-    returnType: TypeDesc;
+    returnType: FunctionReturnTypeDesc;
     isSymmetric?: boolean;
     params: FunctionParameterDef[];
     supportsOrderBy?: boolean | 'only_default';
     supportsLimit?: boolean;
+    genericTypes?: {
+        name: string;
+        acceptibleTypes: FunctionGenericTypeDef[];
+    }[];
     dialect: {
         [dialect: string]: {
             e: Expr;
@@ -776,7 +823,7 @@ export interface QueryResult extends CompiledQuery {
     profilingUrl?: string;
 }
 export declare function isTurtle(def: TypedDef): def is TurtleDef;
-export declare function isAtomic(def: TypedDef): def is AtomicTypeDef;
+export declare function isAtomic(def: TypedDef | ExpressionValueTypeDef): def is AtomicTypeDef;
 export interface SearchResultRow {
     field_name: string;
     field_value: string;
@@ -810,7 +857,7 @@ export interface PrepareResultOptions {
     replaceMaterializedReferences?: boolean;
     materializedTablePrefix?: string;
 }
-type UTD = AtomicTypeDef | FunctionParamTypeDesc | undefined;
+type UTD = AtomicTypeDef | TypedDef | FunctionParameterTypeDef | FunctionReturnTypeDef | undefined;
 /**
  * A set of utilities for asking questions TypeDef/TypeDesc
  * (which is OK because TypeDesc is an extension of a TypeDef)

package/dist/model/malloy_types.js

@@ -1,6 +1,7 @@
 "use strict";
 /*
  * Copyright 2023 Google LLC
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
@@ -22,8 +23,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBaseTable = exports.isSourceDef = exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isScalarArray = exports.isRepeatedRecord = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
-exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isLeafAtomic = exports.mergeEvalSpaces = exports.isLiteral = void 0;
+exports.isSourceDef = exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isScalarArray = exports.isRepeatedRecord = exports.isRepeatedRecordFunctionParam = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
+exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isLeafAtomic = exports.mergeEvalSpaces = exports.isLiteral = exports.isBaseTable = void 0;
 function exprHasKids(e) {
     return 'kids' in e;
 }
@@ -217,6 +218,10 @@ function mkArrayDef(ofType, name) {
     };
 }
 exports.mkArrayDef = mkArrayDef;
+function isRepeatedRecordFunctionParam(paramT) {
+    return (paramT.type === 'array' && paramT.elementTypeDef.type === 'record_element');
+}
+exports.isRepeatedRecordFunctionParam = isRepeatedRecordFunctionParam;
 function isRepeatedRecord(fd) {
     return fd.type === 'array' && fd.elementTypeDef.type === 'record_element';
 }
@@ -477,10 +482,10 @@ exports.TD = {
             ) {
                 return exports.TD.eq(x.elementTypeDef, y.elementTypeDef);
             }
-            return checkFields(x, y);
+            return exports.TD.isAtomic(x) && exports.TD.isAtomic(y) && checkFields(x, y);
         }
         else if (x.type === 'record' && y.type === 'record') {
-            return checkFields(x, y);
+            return exports.TD.isAtomic(x) && exports.TD.isAtomic(y) && checkFields(x, y);
         }
         if (x.type === 'sql native' && y.type === 'sql native') {
             return x.rawType !== undefined && x.rawType === y.rawType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.223-dev241213043533",
+  "version": "0.0.223-dev241216191808",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",