@elaraai/east 0.0.1-beta.0

package/dist/src/builtins.js

@@ -0,0 +1,1105 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, NullType, RefType, SetType, StringType, StructType, VariantType } from "./types.js";
+import { DateTimeFormatTokenType } from "./datetime_format/types.js";
+/** @internal */
+export const Builtins = {
+    Is: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    Equal: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    NotEqual: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    Less: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    LessEqual: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    Greater: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    GreaterEqual: {
+        type_parameters: ["T"],
+        inputs: ["T", "T"],
+        output: BooleanType,
+    },
+    BooleanNot: {
+        type_parameters: [],
+        inputs: [BooleanType],
+        output: BooleanType,
+    },
+    BooleanOr: {
+        type_parameters: [],
+        inputs: [BooleanType, BooleanType],
+        output: BooleanType,
+    },
+    BooleanAnd: {
+        type_parameters: [],
+        inputs: [BooleanType, BooleanType],
+        output: BooleanType,
+    },
+    BooleanXor: {
+        type_parameters: [],
+        inputs: [BooleanType, BooleanType],
+        output: BooleanType,
+    },
+    IntegerToFloat: {
+        type_parameters: [],
+        inputs: [IntegerType],
+        output: FloatType,
+    },
+    IntegerNegate: {
+        type_parameters: [],
+        inputs: [IntegerType],
+        output: IntegerType,
+    },
+    IntegerAdd: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerSubtract: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerMultiply: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerDivide: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerRemainder: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerPow: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    IntegerAbs: {
+        type_parameters: [],
+        inputs: [IntegerType],
+        output: IntegerType,
+    },
+    IntegerSign: {
+        type_parameters: [],
+        inputs: [IntegerType],
+        output: IntegerType,
+    },
+    IntegerLog: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType],
+        output: IntegerType,
+    },
+    FloatToInteger: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: IntegerType,
+    },
+    FloatNegate: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatAdd: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatSubtract: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatMultiply: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatDivide: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatRemainder: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatPow: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType],
+        output: FloatType,
+    },
+    FloatAbs: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatSign: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatSqrt: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatExp: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatLog: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatSin: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatCos: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    FloatTan: {
+        type_parameters: [],
+        inputs: [FloatType],
+        output: FloatType,
+    },
+    StringConcat: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: StringType,
+    },
+    StringRepeat: {
+        type_parameters: [],
+        inputs: [StringType, IntegerType],
+        output: StringType,
+    },
+    StringLength: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: IntegerType,
+    },
+    StringSubstring: {
+        type_parameters: [],
+        inputs: [StringType, IntegerType, IntegerType],
+        output: StringType,
+    },
+    StringUpperCase: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: StringType,
+    },
+    StringLowerCase: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: StringType,
+    },
+    StringSplit: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: ArrayType(StringType),
+    },
+    StringTrim: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: StringType,
+    },
+    StringTrimStart: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: StringType,
+    },
+    StringTrimEnd: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: StringType,
+    },
+    StringStartsWith: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: BooleanType,
+    },
+    StringEndsWith: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: BooleanType,
+    },
+    StringContains: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: BooleanType,
+    },
+    StringIndexOf: {
+        type_parameters: [],
+        inputs: [StringType, StringType],
+        output: IntegerType,
+    },
+    StringReplace: {
+        type_parameters: [],
+        inputs: [StringType, StringType, StringType],
+        output: StringType,
+    },
+    RegexContains: {
+        type_parameters: [],
+        inputs: [StringType, StringType, StringType],
+        output: BooleanType,
+    },
+    RegexIndexOf: {
+        type_parameters: [],
+        inputs: [StringType, StringType, StringType],
+        output: IntegerType,
+    },
+    RegexReplace: {
+        type_parameters: [],
+        inputs: [StringType, StringType, StringType, StringType],
+        output: StringType,
+    },
+    StringEncodeUtf8: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: BlobType,
+    },
+    StringEncodeUtf16: {
+        type_parameters: [],
+        inputs: [StringType],
+        output: BlobType,
+    },
+    Print: {
+        type_parameters: ["T"],
+        inputs: ["T"],
+        output: StringType,
+    },
+    Parse: {
+        type_parameters: ["T"],
+        inputs: [StringType],
+        output: "T",
+    },
+    StringPrintJSON: {
+        type_parameters: ["T"],
+        inputs: ["T"],
+        output: StringType,
+    },
+    StringParseJSON: {
+        type_parameters: ["T"],
+        inputs: [StringType],
+        output: "T",
+    },
+    DateTimeGetYear: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetMonth: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetDayOfMonth: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetHour: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetMinute: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetSecond: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetMillisecond: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeGetDayOfWeek: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeToEpochMilliseconds: {
+        type_parameters: [],
+        inputs: [DateTimeType],
+        output: IntegerType,
+    },
+    DateTimeFromEpochMilliseconds: {
+        type_parameters: [],
+        inputs: [IntegerType],
+        output: DateTimeType,
+    },
+    DateTimeFromComponents: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType, IntegerType, IntegerType, IntegerType, IntegerType, IntegerType],
+        output: DateTimeType,
+    },
+    DateTimeAddMilliseconds: {
+        type_parameters: [],
+        inputs: [DateTimeType, IntegerType],
+        output: DateTimeType,
+    },
+    DateTimeDurationMilliseconds: {
+        type_parameters: [],
+        inputs: [DateTimeType, DateTimeType],
+        output: IntegerType,
+    },
+    DateTimePrintFormat: {
+        type_parameters: [],
+        inputs: [DateTimeType, ArrayType(DateTimeFormatTokenType)],
+        output: StringType,
+    },
+    DateTimeParseFormat: {
+        type_parameters: [],
+        inputs: [StringType, ArrayType(DateTimeFormatTokenType)],
+        output: DateTimeType,
+    },
+    BlobSize: {
+        type_parameters: [],
+        inputs: [BlobType],
+        output: IntegerType,
+    },
+    BlobGetUint8: {
+        type_parameters: [],
+        inputs: [BlobType, IntegerType],
+        output: IntegerType,
+    },
+    BlobDecodeUtf8: {
+        type_parameters: [],
+        inputs: [BlobType],
+        output: StringType,
+    },
+    BlobDecodeUtf16: {
+        type_parameters: [],
+        inputs: [BlobType],
+        output: StringType,
+    },
+    BlobDecodeBeast: {
+        type_parameters: ["T"],
+        inputs: [BlobType],
+        output: "T",
+    },
+    BlobEncodeBeast: {
+        type_parameters: ["T"],
+        inputs: ["T"],
+        output: BlobType,
+    },
+    BlobDecodeBeast2: {
+        type_parameters: ["T"],
+        inputs: [BlobType],
+        output: "T",
+    },
+    BlobEncodeBeast2: {
+        type_parameters: ["T"],
+        inputs: ["T"],
+        output: BlobType,
+    },
+    RefGet: {
+        type_parameters: ["T"],
+        inputs: [RefType("T")],
+        output: "T",
+    },
+    RefUpdate: {
+        type_parameters: ["T"],
+        inputs: [RefType("T"), "T"],
+        output: NullType,
+    },
+    RefMerge: {
+        type_parameters: ["T", "T2"],
+        inputs: [RefType("T"), "T2", FunctionType(["T", "T2"], "T", null)],
+        output: NullType,
+    },
+    ArrayGenerate: {
+        type_parameters: ["T"],
+        inputs: [IntegerType, FunctionType([IntegerType], "T", null)],
+        output: ArrayType("T"),
+    },
+    ArrayRange: {
+        type_parameters: [],
+        inputs: [IntegerType, IntegerType, IntegerType],
+        output: ArrayType(IntegerType),
+    },
+    ArrayLinspace: {
+        type_parameters: [],
+        inputs: [FloatType, FloatType, IntegerType],
+        output: ArrayType(FloatType),
+    },
+    ArraySize: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: IntegerType,
+    },
+    ArrayHas: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType],
+        output: BooleanType,
+    },
+    ArrayGet: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType],
+        output: "T",
+    },
+    ArrayGetOrDefault: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType, FunctionType([IntegerType], "T", null)],
+        output: "T",
+    },
+    ArrayTryGet: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType],
+        output: VariantType({ none: NullType, some: "T" }),
+    },
+    ArrayUpdate: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType, "T"],
+        output: NullType,
+    },
+    ArrayMerge: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), IntegerType, "T2", FunctionType(["T", "T2", IntegerType], "T", null)],
+        output: NullType,
+    },
+    ArrayPushLast: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), "T"],
+        output: NullType,
+    },
+    ArrayPopLast: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: "T",
+    },
+    ArrayPushFirst: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), "T"],
+        output: NullType,
+    },
+    ArrayPopFirst: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: "T",
+    },
+    ArrayAppend: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), ArrayType("T")],
+        output: NullType,
+    },
+    ArrayPrepend: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), ArrayType("T")],
+        output: NullType,
+    },
+    ArrayMergeAll: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), ArrayType("T2"), FunctionType(["T", "T2", IntegerType], "T", null)],
+        output: NullType,
+    },
+    ArrayClear: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: NullType,
+    },
+    ArraySortInPlace: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T"], "T2", null)],
+        output: NullType,
+    },
+    ArrayReverseInPlace: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: NullType,
+    },
+    ArraySort: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T"], "T2", null)],
+        output: ArrayType("T"),
+    },
+    ArrayReverse: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: ArrayType("T"),
+    },
+    ArrayIsSorted: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T"], "T2", null)],
+        output: BooleanType,
+    },
+    ArrayFindSortedFirst: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), "T2", FunctionType(["T"], "T2", null)],
+        output: IntegerType,
+    },
+    ArrayFindSortedLast: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), "T2", FunctionType(["T"], "T2", null)],
+        output: IntegerType,
+    },
+    ArrayFindSortedRange: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), "T2", FunctionType(["T"], "T2", null)],
+        output: StructType({ start: IntegerType, end: IntegerType }),
+    },
+    ArrayFindFirst: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), "T2", FunctionType(["T"], "T2", null)],
+        output: VariantType({ none: NullType, some: IntegerType }),
+    },
+    ArrayConcat: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), ArrayType("T")],
+        output: ArrayType("T"),
+    },
+    ArraySlice: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), IntegerType, IntegerType],
+        output: ArrayType("T"),
+    },
+    ArrayGetKeys: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), ArrayType(IntegerType), FunctionType([IntegerType], "T", null)],
+        output: ArrayType("T"),
+    },
+    ArrayForEach: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "T2", null)],
+        output: NullType,
+    },
+    ArrayCopy: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T")],
+        output: ArrayType("T"),
+    },
+    ArrayMap: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "T2", null)],
+        output: ArrayType("T2"),
+    },
+    ArrayFilter: {
+        type_parameters: ["T"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], BooleanType, null)],
+        output: ArrayType("T"),
+    },
+    ArrayFilterMap: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], VariantType({ none: NullType, some: "T2" }), null)],
+        output: ArrayType("T2"),
+    },
+    ArrayFirstMap: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], VariantType({ none: NullType, some: "T2" }), null)],
+        output: VariantType({ none: NullType, some: "T2" }),
+    },
+    ArrayFold: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), "T2", FunctionType(["T2", "T", IntegerType], "T2", null)],
+        output: "T2",
+    },
+    ArrayMapReduce: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "T2", null), FunctionType(["T2", "T2"], "T2", null)],
+        output: "T2",
+    },
+    ArrayStringJoin: {
+        type_parameters: [],
+        inputs: [ArrayType(StringType), StringType],
+        output: StringType,
+    },
+    ArrayToSet: {
+        type_parameters: ["T", "K2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "K2", null)],
+        output: SetType("K2"),
+    },
+    ArrayToDict: {
+        type_parameters: ["T", "K2", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "K2", null), FunctionType(["T", IntegerType], "T2", null), FunctionType(["T2", "T2", "K2"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    ArrayFlattenToArray: {
+        type_parameters: ["T", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], ArrayType("T2"), null)],
+        output: ArrayType("T2"),
+    },
+    ArrayFlattenToSet: {
+        type_parameters: ["T", "K2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], SetType("K2"), null)],
+        output: SetType("K2"),
+    },
+    ArrayFlattenToDict: {
+        type_parameters: ["T", "K2", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], DictType("K2", "T2"), null), FunctionType(["T2", "T2", "K2"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    ArrayGroupFold: {
+        type_parameters: ["T", "K2", "T2"],
+        inputs: [ArrayType("T"), FunctionType(["T", IntegerType], "K2", null), FunctionType(["K2"], "T2", null), FunctionType(["T2", "T", IntegerType], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    SetGenerate: {
+        type_parameters: ["K"],
+        inputs: [IntegerType, FunctionType([IntegerType], "K", null), FunctionType(["K"], NullType, null)],
+        output: SetType("K"),
+    },
+    SetSize: {
+        type_parameters: ["K"],
+        inputs: [SetType("K")],
+        output: IntegerType,
+    },
+    SetHas: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), "K"],
+        output: BooleanType,
+    },
+    SetInsert: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), "K"],
+        output: NullType,
+    },
+    SetTryInsert: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), "K"],
+        output: BooleanType,
+    },
+    SetDelete: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), "K"],
+        output: NullType,
+    },
+    SetTryDelete: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), "K"],
+        output: BooleanType,
+    },
+    SetUnionInPlace: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: NullType,
+    },
+    SetClear: {
+        type_parameters: ["K"],
+        inputs: [SetType("K")],
+        output: NullType,
+    },
+    SetUnion: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: SetType("K"),
+    },
+    SetIntersect: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: SetType("K"),
+    },
+    SetDiff: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: SetType("K"),
+    },
+    SetSymDiff: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: SetType("K"),
+    },
+    SetIsSubset: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: BooleanType,
+    },
+    SetIsDisjoint: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), SetType("K")],
+        output: BooleanType,
+    },
+    SetCopy: {
+        type_parameters: ["K"],
+        inputs: [SetType("K")],
+        output: SetType("K"),
+    },
+    SetForEach: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "T2", null)],
+        output: NullType,
+    },
+    SetMap: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "T2", null)],
+        output: DictType("K", "T2"),
+    },
+    SetFilter: {
+        type_parameters: ["K"],
+        inputs: [SetType("K"), FunctionType(["K"], BooleanType, null)],
+        output: SetType("K"),
+    },
+    SetFilterMap: {
+        type_parameters: ["K", "V2"],
+        inputs: [SetType("K"), FunctionType(["K"], VariantType({ none: NullType, some: "V2" }), null)],
+        output: DictType("K", "V2"),
+    },
+    SetFirstMap: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], VariantType({ none: NullType, some: "T2" }), null)],
+        output: VariantType({ none: NullType, some: "T2" }),
+    },
+    SetMapReduce: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "T2", null), FunctionType(["T2", "T2"], "T2", null)],
+        output: "T2",
+    },
+    SetReduce: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["T2", "K"], "T2", null), "T2"],
+        output: "T2",
+    },
+    SetToArray: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "T2", null)],
+        output: ArrayType("T2"),
+    },
+    SetToSet: {
+        type_parameters: ["K", "K2"],
+        inputs: [SetType("K"), FunctionType(["K"], "K2", null)],
+        output: SetType("K2"),
+    },
+    SetToDict: {
+        type_parameters: ["K", "K2", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "K2", null), FunctionType(["K"], "T2", null), FunctionType(["T2", "T2", "K2"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    SetFlattenToArray: {
+        type_parameters: ["K", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], ArrayType("T2"), null)],
+        output: ArrayType("T2"),
+    },
+    SetFlattenToSet: {
+        type_parameters: ["K", "K2"],
+        inputs: [SetType("K"), FunctionType(["K"], SetType("K2"), null)],
+        output: SetType("K2"),
+    },
+    SetFlattenToDict: {
+        type_parameters: ["K", "K2", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], DictType("K2", "T2"), null), FunctionType(["T2", "T2", "K2"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    SetGroupFold: {
+        type_parameters: ["K", "K2", "T2"],
+        inputs: [SetType("K"), FunctionType(["K"], "K2", null), FunctionType(["K2"], "T2", null), FunctionType(["T2", "K"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+    DictGenerate: {
+        type_parameters: ["K", "V"],
+        inputs: [IntegerType, FunctionType([IntegerType], "K", null), FunctionType([IntegerType], "V", null), FunctionType(["V", "V", "K"], "V", null)],
+        output: DictType("K", "V"),
+    },
+    DictSize: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V")],
+        output: IntegerType,
+    },
+    DictHas: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: BooleanType,
+    },
+    DictGet: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: "V",
+    },
+    DictGetOrDefault: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", FunctionType(["K"], "V", null)],
+        output: "V",
+    },
+    DictTryGet: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: VariantType({ none: NullType, some: "V" }),
+    },
+    DictInsert: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", "V"],
+        output: NullType,
+    },
+    DictInsertOrUpdate: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", "V", FunctionType(["V", "V", "K"], "V", null)],
+        output: NullType,
+    },
+    DictGetOrInsert: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", FunctionType(["K"], "V", null)],
+        output: "V",
+    },
+    DictUpdate: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", "V"],
+        output: NullType,
+    },
+    DictSwap: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K", "V"],
+        output: "V",
+    },
+    DictMerge: {
+        type_parameters: ["K", "V", "V2"],
+        inputs: [DictType("K", "V"), "K", "V2", FunctionType(["V", "V2", "K"], "V", null), FunctionType(["K"], "V", null)],
+        output: NullType,
+    },
+    DictDelete: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: NullType,
+    },
+    DictTryDelete: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: BooleanType,
+    },
+    DictPop: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), "K"],
+        output: "V",
+    },
+    DictClear: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V")],
+        output: NullType,
+    },
+    DictUnionInPlace: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), DictType("K", "V"), FunctionType(["V", "V", "K"], "V", null)],
+        output: NullType,
+    },
+    DictMergeAll: {
+        type_parameters: ["K", "V", "V2"],
+        inputs: [DictType("K", "V"), DictType("K", "V2"), FunctionType(["V", "V2", "K"], "V", null), FunctionType(["K"], "V", null)],
+        output: NullType,
+    },
+    DictKeys: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V")],
+        output: SetType("K"),
+    },
+    DictGetKeys: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), SetType("K"), FunctionType(["K"], "V", null)],
+        output: DictType("K", "V"),
+    },
+    DictForEach: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "T2", null)],
+        output: NullType,
+    },
+    DictCopy: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V")],
+        output: DictType("K", "V"),
+    },
+    DictMap: {
+        type_parameters: ["K", "V", "V2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "V2", null)],
+        output: DictType("K", "V2"),
+    },
+    DictFilter: {
+        type_parameters: ["K", "V"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], BooleanType, null)],
+        output: DictType("K", "V"),
+    },
+    DictFilterMap: {
+        type_parameters: ["K", "V", "V2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], VariantType({ none: NullType, some: "V2" }), null)],
+        output: DictType("K", "V2"),
+    },
+    DictFirstMap: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], VariantType({ none: NullType, some: "T2" }), null)],
+        output: VariantType({ none: NullType, some: "T2" }),
+    },
+    DictMapReduce: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "T2", null), FunctionType(["T2", "T2"], "T2", null)],
+        output: "T2",
+    },
+    DictReduce: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["T2", "V", "K"], "T2", null), "T2"],
+        output: "T2",
+    },
+    DictToArray: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "T2", null)],
+        output: ArrayType("T2"),
+    },
+    DictToSet: {
+        type_parameters: ["K", "V", "K2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "K2", null)],
+        output: SetType("K2"),
+    },
+    DictToDict: {
+        type_parameters: ["K", "V", "K2", "V2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "K2", null), FunctionType(["V", "K"], "V2", null), FunctionType(["V2", "V2", "K2"], "V2", null)],
+        output: DictType("K2", "V2"),
+    },
+    DictFlattenToArray: {
+        type_parameters: ["K", "V", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], ArrayType("T2"), null)],
+        output: ArrayType("T2"),
+    },
+    DictFlattenToSet: {
+        type_parameters: ["K", "V", "K2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], SetType("K2"), null)],
+        output: SetType("K2"),
+    },
+    DictFlattenToDict: {
+        type_parameters: ["K", "V", "K2", "V2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], DictType("K2", "V2"), null), FunctionType(["V2", "V2", "K2"], "V2", null)],
+        output: DictType("K2", "V2"),
+    },
+    DictGroupFold: {
+        type_parameters: ["K", "V", "K2", "T2"],
+        inputs: [DictType("K", "V"), FunctionType(["V", "K"], "K2", null), FunctionType(["K2"], "T2", null), FunctionType(["T2", "V", "K"], "T2", null)],
+        output: DictType("K2", "T2"),
+    },
+};
+/** @internal */
+export function applyTypeParameters(type, params, inStack, outStack) {
+    const idx = inStack.indexOf(type);
+    if (idx !== -1) {
+        return outStack[idx];
+    }
+    if (typeof (type) === "string") {
+        let ret = params.get(type);
+        if (ret === undefined) {
+            throw new Error(`Unable to find type parameter ${JSON.stringify(type)}`);
+        }
+        return ret;
+    }
+    else if (type.type === "Null" || type.type === "Boolean" || type.type === "Integer" || type.type === "Float" || type.type === "String" || type.type === "DateTime" || type.type === "Blob" || type.type === "Never") {
+        return type;
+    }
+    else if (type.type === "Ref") {
+        const self = { type: "Ref", value: undefined };
+        inStack.push(type);
+        outStack.push(self);
+        self.value = applyTypeParameters(type.value, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Array") {
+        const self = { type: "Array", value: undefined };
+        inStack.push(type);
+        outStack.push(self);
+        self.value = applyTypeParameters(type.value, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Set") {
+        const self = { type: "Set", key: undefined };
+        inStack.push(type);
+        outStack.push(self);
+        self.key = applyTypeParameters(type.key, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Dict") {
+        const self = { type: "Dict", key: undefined, value: undefined };
+        inStack.push(type);
+        outStack.push(self);
+        self.key = applyTypeParameters(type.key, params, inStack, outStack);
+        self.value = applyTypeParameters(type.value, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Struct") {
+        const self = { type: "Struct", fields: {} };
+        inStack.push(type);
+        outStack.push(self);
+        for (const [name, fieldType] of Object.entries(type.fields)) {
+            self.fields[name] = applyTypeParameters(fieldType, params, inStack, outStack);
+        }
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Variant") {
+        const self = { type: "Variant", cases: {} };
+        inStack.push(type);
+        outStack.push(self);
+        for (const [name, caseType] of Object.entries(type.cases)) {
+            self.cases[name] = applyTypeParameters(caseType, params, inStack, outStack);
+        }
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Recursive") {
+        const self = { type: "Recursive", node: undefined };
+        inStack.push(type);
+        outStack.push(self);
+        self.node = applyTypeParameters(type.node, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else if (type.type === "Function") {
+        const self = {
+            type: "Function",
+            inputs: [],
+            output: undefined,
+            platforms: type.platforms,
+        };
+        inStack.push(type);
+        outStack.push(self);
+        for (const inputType of type.inputs) {
+            self.inputs.push(applyTypeParameters(inputType, params, inStack, outStack));
+        }
+        self.output = applyTypeParameters(type.output, params, inStack, outStack);
+        inStack.pop();
+        outStack.pop();
+        return self;
+    }
+    else {
+        throw new Error(`Unhandled type ${type.type}`);
+    }
+}
+//# sourceMappingURL=builtins.js.map