@malloydata/malloy 0.0.223-dev241212225931 → 0.0.223-dev241216182944

package/dist/dialect/duckdb/dialect_functions.js

@@ -7,6 +7,12 @@
  */
 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',
@@ -65,6 +71,7 @@ const string_agg_distinct = {
     },
 };
 exports.DUCKDB_DIALECT_FUNCTIONS = {
+    list_extract,
     count_approx,
     dayname,
     to_timestamp,

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,35 @@ 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 type TypeDescElementBlueprint = LeafExpressionType | ArrayBlueprint | RecordBlueprint;
-export type TypeDescBlueprint = TypeDescElementBlueprint | {
+export type LeafPlusType = LeafExpressionType | 'any';
+export type TypeDescElementBlueprint = LeafPlusType | ArrayBlueprint | RecordBlueprint;
+export type NamedGeneric = {
     generic: string;
+};
+export type TypeDescBlueprint = TypeDescElementBlueprintOrNamedGeneric | {
+    literal: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    literal: LeafExpressionType | {
-        generic: string;
-    };
+    constant: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    constant: LeafExpressionType | {
-        generic: string;
-    };
+    dimension: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    dimension: LeafExpressionType | {
-        generic: string;
-    };
+    measure: TypeDescElementBlueprintOrNamedGeneric;
 } | {
-    measure: LeafExpressionType | {
-        generic: string;
-    };
-} | {
-    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,83 @@ 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 };
+    }
+    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 {
-        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' ||
@@ -261,51 +254,51 @@ 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 {
-        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 +386,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 +413,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 +428,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' },