ballerina-core 1.0.213 → 1.0.215

package/bin/src/forms/domains/parser/domains/predicates/state.js

@@ -1,1276 +1,1050 @@
 import { Map, Set, List, OrderedMap } from "immutable";
-import {
-  ValueOrErrors,
-  MapRepo,
-  Updater,
-  simpleUpdater,
-  replaceWith,
-  ListRepo,
-} from "../../../../../../main";
+import { ValueOrErrors, MapRepo, Updater, simpleUpdater, replaceWith, ListRepo, } from "../../../../../../main";
 const calculateVisibility = (expr, bindings) => {
-  if (typeof expr == "boolean") {
-    return ValueOrErrors.Default.return(expr);
-  }
-  return Expr.Operations.Evaluate(bindings)(expr).Then((result) => {
-    if (typeof result == "boolean") {
-      return ValueOrErrors.Default.return(result);
+    if (typeof expr == "boolean") {
+        return ValueOrErrors.Default.return(expr);
     }
-    return ValueOrErrors.Default.throwOne(
-      `Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`,
-    );
-  });
+    return Expr.Operations.Evaluate(bindings)(expr).Then((result) => {
+        if (typeof result == "boolean") {
+            return ValueOrErrors.Default.return(result);
+        }
+        return ValueOrErrors.Default.throwOne(`Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`);
+    });
 };
 export const FieldPredicateExpression = {
-  Default: {
-    unit: (value) => ({ kind: "unit", value }),
-    primitive: (value) => ({
-      kind: "primitive",
-      value,
-    }),
-    record: (value, fields) => ({ kind: "record", value, fields }),
-    list: (value, elementExpression) => ({
-      kind: "list",
-      value,
-      elementExpression,
-    }),
-    map: (value, keyExpression, valueExpression) => ({
-      kind: "map",
-      value,
-      keyExpression,
-      valueExpression,
-    }),
-    tuple: (value, elementExpressions) => ({
-      kind: "tuple",
-      value,
-      elementExpressions,
-    }),
-    sum: (value, leftExpression, rightExpression) => ({
-      kind: "sum",
-      value,
-      leftExpression:
-        leftExpression !== null && leftExpression !== void 0
-          ? leftExpression
-          : FieldPredicateExpression.Default.unit(false),
-      rightExpression:
-        rightExpression !== null && rightExpression !== void 0
-          ? rightExpression
-          : FieldPredicateExpression.Default.unit(false),
-    }),
-  },
+    Default: {
+        unit: (value) => ({ kind: "unit", value }),
+        primitive: (value) => ({
+            kind: "primitive",
+            value,
+        }),
+        record: (value, fields) => ({ kind: "record", value, fields }),
+        list: (value, elementExpression) => ({ kind: "list", value, elementExpression }),
+        map: (value, keyExpression, valueExpression) => ({
+            kind: "map",
+            value,
+            keyExpression,
+            valueExpression,
+        }),
+        tuple: (value, elementExpressions) => ({
+            kind: "tuple",
+            value,
+            elementExpressions,
+        }),
+        sum: (value, leftExpression, rightExpression) => ({
+            kind: "sum",
+            value,
+            leftExpression: leftExpression !== null && leftExpression !== void 0 ? leftExpression : FieldPredicateExpression.Default.unit(false),
+            rightExpression: rightExpression !== null && rightExpression !== void 0 ? rightExpression : FieldPredicateExpression.Default.unit(false),
+        }),
+    },
 };
 export const FormFieldPredicateEvaluation = {
-  Default: {
-    unit: (value) => ({
-      kind: "unit",
-      value,
-    }),
-    primitive: (value) => ({
-      kind: "primitive",
-      value,
-    }),
-    form: (value, fields) => ({ kind: "form", value, fields }),
-    list: (value, elementValues) => ({
-      kind: "list",
-      value,
-      elementValues,
-    }),
-    map: (value, elementValues) => ({ kind: "map", value, elementValues }),
-    tuple: (value, elementValues) => ({
-      kind: "tuple",
-      value,
-      elementValues,
-    }),
-    sum: (value, innerValue) => ({ kind: "sum", value, innerValue }),
-  },
+    Default: {
+        unit: (value) => ({
+            kind: "unit",
+            value,
+        }),
+        primitive: (value) => ({
+            kind: "primitive",
+            value,
+        }),
+        form: (value, fields) => ({ kind: "form", value, fields }),
+        list: (value, elementValues) => ({
+            kind: "list",
+            value,
+            elementValues,
+        }),
+        map: (value, elementValues) => ({ kind: "map", value, elementValues }),
+        tuple: (value, elementValues) => ({
+            kind: "tuple",
+            value,
+            elementValues,
+        }),
+        sum: (value, innerValue) => ({ kind: "sum", value, innerValue }),
+    },
 };
 export const ValueRecord = {
-  Default: {
-    empty: () => ({ kind: "record", fields: OrderedMap() }),
-    fromJSON: (json) => ({
-      kind: "record",
-      fields: OrderedMap(Object.assign({}, json)), // TODO - check this works ok
-    }),
-    fromMap: (map) => ({
-      kind: "record",
-      fields: OrderedMap(map),
-    }),
-  },
-  Operations: {
-    has: (record, key) => {
-      return record.fields.has(key);
-    },
-  },
-  Updaters: Object.assign(Object.assign({}, simpleUpdater()("fields")), {
-    update: (key, updater) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.update(key, updater));
-    },
-    set: (key, value) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.set(key, value));
-    },
-    remove: (key) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.remove(key));
+    Default: {
+        empty: () => ({ kind: "record", fields: OrderedMap() }),
+        fromJSON: (json) => ({
+            kind: "record",
+            fields: OrderedMap(Object.assign({}, json)), // TODO - check this works ok
+        }),
+        fromMap: (map) => ({
+            kind: "record",
+            fields: OrderedMap(map),
+        }),
     },
-    clear: () => {
-      return ValueRecord.Updaters.fields(replaceWith(OrderedMap()));
+    Operations: {
+        has: (record, key) => {
+            return record.fields.has(key);
+        },
     },
-  }),
+    Updaters: Object.assign(Object.assign({}, simpleUpdater()("fields")), { update: (key, updater) => {
+            return ValueRecord.Updaters.fields(MapRepo.Updaters.update(key, updater));
+        }, set: (key, value) => {
+            return ValueRecord.Updaters.fields(MapRepo.Updaters.set(key, value));
+        }, remove: (key) => {
+            return ValueRecord.Updaters.fields(MapRepo.Updaters.remove(key));
+        }, clear: () => {
+            return ValueRecord.Updaters.fields(replaceWith(OrderedMap()));
+        } }),
 };
 export const ValueUnionCase = {
-  Default: (caseName, fields) => ({
-    kind: "unionCase",
-    caseName,
-    fields,
-  }),
-  Updaters: Object.assign(
-    {
-      case: (caseName) => (upd) =>
-        Updater((v) => ValueUnionCase.Default(caseName, upd(v.fields))),
-    },
-    simpleUpdater()("fields"),
-  ),
+    Default: (caseName, fields) => ({
+        kind: "unionCase",
+        caseName,
+        fields,
+    }),
+    Updaters: Object.assign({ case: (caseName) => (upd) => Updater((v) => ValueUnionCase.Default(caseName, upd(v.fields))) }, simpleUpdater()("fields")),
 };
 export const ValueUnit = {
-  Default: () => ({ kind: "unit" }),
+    Default: () => ({ kind: "unit" }),
 };
 export const ValueOption = {
-  Default: {
-    some: (value) => ({
-      kind: "option",
-      isSome: true,
-      value,
-    }),
-    none: () => ({
-      kind: "option",
-      isSome: false,
-      value: { kind: "unit" },
-    }),
-  },
-  Updaters: {
-    value: (_) => Updater((v) => ValueOption.Default.some(_(v))),
-  },
+    Default: {
+        some: (value) => ({
+            kind: "option",
+            isSome: true,
+            value,
+        }),
+        none: () => ({
+            kind: "option",
+            isSome: false,
+            value: { kind: "unit" },
+        }),
+    },
+    Updaters: {
+        value: (_) => Updater((v) => ValueOption.Default.some(_(v))),
+    },
 };
 export const ValueSum = {
-  Default: (value) => ({
-    kind: "sum",
-    value,
-  }),
-  Updaters: Object.assign({}, simpleUpdater()("value")),
+    Default: (value) => ({
+        kind: "sum",
+        value,
+    }),
+    Updaters: Object.assign({}, simpleUpdater()("value")),
+};
+export const ValueSumN = {
+    Default: (caseIndex, arity, value) => ({
+        kind: "sumN",
+        caseIndex,
+        arity,
+        value,
+    }),
+    Updaters: Object.assign({ case: (caseIndex) => (upd) => Updater((v) => ValueSumN.Default(caseIndex, v.arity, upd(v.value))) }, simpleUpdater()("value")),
 };
 export const ValueTuple = {
-  Default: () => ({
-    kind: "tuple",
-    values: List(),
-  }),
-  Updaters: Object.assign({}, simpleUpdater()("values")),
+    Default: () => ({
+        kind: "tuple",
+        values: List(),
+    }),
+    Updaters: Object.assign({}, simpleUpdater()("values")),
 };
 export const ValueTable = {
-  Default: {
-    empty: () => ({
-      kind: "table",
-      from: 0,
-      to: 0,
-      data: OrderedMap(),
-      hasMoreValues: false,
+    Default: {
+        empty: () => ({
+            kind: "table",
+            from: 0,
+            to: 0,
+            data: OrderedMap(),
+            hasMoreValues: false,
+        }),
+        fromParsed: (from, to, hasMoreValues, data) => ({
+            kind: "table",
+            from,
+            to,
+            data,
+            hasMoreValues,
+        }),
+    },
+    Updaters: Object.assign({}, simpleUpdater()("data")),
+};
+export const ValueFilterContains = {
+    Default: (contains) => ({
+        kind: "contains",
+        contains,
     }),
-    fromParsed: (from, to, hasMoreValues, data) => ({
-      kind: "table",
-      from,
-      to,
-      data,
-      hasMoreValues,
+};
+export const ValueFilterEqualsTo = {
+    Default: (equalsTo) => ({
+        kind: "=",
+        equalsTo,
     }),
-  },
-  Updaters: Object.assign({}, simpleUpdater()("data")),
 };
-export const BinaryOperators = ["or", "equals"];
-export const BinaryOperatorsSet = Set(BinaryOperators);
-export const PredicateValue = {
-  Default: {
-    string: () => "",
-    number: () => 0,
-    boolean: () => false,
-    date: () => new Date(),
-    unit: () => ({ kind: "unit" }),
-    tuple: (values) => ({
-      kind: "tuple",
-      values,
+export const ValueFilterNotEqualsTo = {
+    Default: (notEqualsTo) => ({
+        kind: "!=",
+        notEqualsTo,
     }),
-    record: (fields) => ({
-      kind: "record",
-      fields,
+};
+export const ValueFilterGreaterThanOrEqualsTo = {
+    Default: (greaterThanOrEqualsTo) => ({
+        kind: ">=",
+        greaterThanOrEqualsTo,
     }),
-    unionCase: (caseName, fields) => ({
-      kind: "unionCase",
-      caseName,
-      fields,
+};
+export const ValueFilterGreaterThan = {
+    Default: (greaterThan) => ({
+        kind: ">",
+        greaterThan,
     }),
-    option: (isSome, value) => ({
-      kind: "option",
-      isSome,
-      value,
+};
+export const ValueFilterIsNotNull = {
+    Default: () => ({
+        kind: "!=null",
     }),
-    varLookup: (varName) => ({
-      kind: "varLookup",
-      varName,
+};
+export const ValueFilterIsNull = {
+    Default: () => ({
+        kind: "=null",
     }),
-    sum: (value) => ({
-      kind: "sum",
-      value,
+};
+export const ValueFilterSmallerThanOrEqualsTo = {
+    Default: (smallerThanOrEqualsTo) => ({
+        kind: "<=",
+        smallerThanOrEqualsTo,
     }),
-    table: (from, to, data, hasMoreValues) => ({
-      kind: "table",
-      from,
-      to,
-      data,
-      hasMoreValues,
+};
+export const ValueFilterSmallerThan = {
+    Default: (smallerThan) => ({
+        kind: "<",
+        smallerThan,
     }),
-  },
-  Operations: {
-    GetKind: (value) =>
-      typeof value == "object"
-        ? "kind" in value
-          ? ValueOrErrors.Default.return(value.kind)
-          : PredicateValue.Operations.IsDate(value)
-            ? ValueOrErrors.Default.return("date")
-            : ValueOrErrors.Default.throwOne("invalid")
-        : ValueOrErrors.Default.return(typeof value),
-    IsPrimitive: (value) => {
-      return (
-        PredicateValue.Operations.IsBoolean(value) ||
-        PredicateValue.Operations.IsNumber(value) ||
-        PredicateValue.Operations.IsString(value) ||
-        PredicateValue.Operations.IsDate(value)
-      );
-    },
-    IsBoolean: (value) => {
-      return typeof value == "boolean";
-    },
-    IsNumber: (value) => {
-      return typeof value == "number";
-    },
-    IsString: (value) => {
-      return typeof value == "string";
-    },
-    IsDate: (value) => {
-      return (
-        typeof value == "object" &&
-        Object.prototype.toString.call(value) === "[object Date]" &&
-        value instanceof Date &&
-        !isNaN(value.getTime())
-      );
-    },
-    IsUnit: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "unit"
-      );
-    },
-    IsUnionCase: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "unionCase"
-      );
-    },
-    IsRecord: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "record"
-      );
-    },
-    IsTuple: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "tuple"
-      );
-    },
-    IsOption: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "option"
-      );
-    },
-    IsTable: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "table"
-      );
-    },
-    IsSum: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "sum"
-      );
-    },
-    IsVarLookup: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "varLookup"
-      );
-    },
-    IsCustom: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "custom"
-      );
-    },
-    ParseAsDate: (json) => {
-      if (PredicateValue.Operations.IsDate(json))
-        return ValueOrErrors.Default.return(json);
-      return ValueOrErrors.Default.throwOne(`date has invalid value property`);
-    },
-    ParseAsVarLookup: (json) => {
-      if (json.kind == "varLookup" && typeof json.varName == "string")
-        return ValueOrErrors.Default.return(
-          PredicateValue.Default.varLookup(json.varName),
-        );
-      return ValueOrErrors.Default.throwOne(
-        `varLookup has invalid varName property`,
-      );
-    },
-    ParseAsUnionCase: (json) => {
-      if (typeof json.caseName == "string")
-        return ValueOrErrors.Default.return(
-          PredicateValue.Default.unionCase(json.caseName, json.value),
-        );
-      return ValueOrErrors.Default.throwOne(
-        `union case has invalid caseName property`,
-      );
-    },
-    ParseAsRecord: (json, types) => {
-      if ("fields" in json && typeof json.fields == "object") {
-        return ValueOrErrors.Operations.All(
-          List(
-            Object.entries(json.fields).map(([fieldName, fieldValue]) =>
-              PredicateValue.Operations.parse(
-                fieldValue,
-                { kind: "expression" },
-                types,
-              ).Then((value) =>
-                ValueOrErrors.Default.return([fieldName, value]),
-              ),
-            ),
-          ),
-        ).Then((entries) =>
-          ValueOrErrors.Default.return(
-            PredicateValue.Default.record(OrderedMap(entries)),
-          ),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(`record has no field property`);
-    },
-    ParseAsTuple: (json, types) => {
-      if (json.values != undefined && Array.isArray(json.values)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            json.values.map((elementValue) =>
-              PredicateValue.Operations.parse(
-                elementValue,
-                { kind: "expression" },
-                types,
-              ),
-            ),
-          ),
-        ).Then((values) =>
-          ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(
-        `Error: tuple has no values property`,
-      );
-    },
-    // TODO -- do we need to add table here ?
-    parse: (json, type, types) => {
-      const result = (() => {
-        if (
-          type.kind == "expression" &&
-          (typeof json == "boolean" ||
-            typeof json == "number" ||
-            typeof json == "string")
-        )
-          return ValueOrErrors.Default.return(json);
-        if (type.kind == "expression" && json.kind == undefined) {
-          return ValueOrErrors.Default.throwOne(
-            `evaluation statement has no kind value`,
-          );
-        }
-        if (type.kind == "expression" && json.kind == "guid") {
-          return ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "expression" && json.kind == "date") {
-          return PredicateValue.Operations.ParseAsDate(json);
-        }
-        if (type.kind == "expression" && json.kind == "unit") {
-          return ValueOrErrors.Default.return(PredicateValue.Default.unit());
-        }
-        if (type.kind == "expression" && json.kind == "varLookup") {
-          return PredicateValue.Operations.ParseAsVarLookup(json);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "record" &&
-          "caseName" in json
-        ) {
-          return PredicateValue.Operations.ParseAsUnionCase(json);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "record" &&
-          "fields" in json
-        ) {
-          return PredicateValue.Operations.ParseAsRecord(json, types);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "tuple" &&
-          "values" in json
-        ) {
-          return PredicateValue.Operations.ParseAsTuple(json, types);
-        }
-        if (type.kind == "primitive" && type.value == "Date") {
-          if (PredicateValue.Operations.IsDate(json)) {
-            return ValueOrErrors.Default.return(json);
-          }
-          return ValueOrErrors.Default.throwOne(
-            `failed to parse date ${JSON.stringify(json)}`,
-          );
-        }
-        if (type.kind == "primitive" && type.value == "maybeBoolean") {
-          return json == undefined
-            ? ValueOrErrors.Default.return(false)
-            : ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "primitive") {
-          return ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "lookup") {
-          const subType = types.get(type.name);
-          if (subType == undefined) {
-            return ValueOrErrors.Default.throwOne(
-              `cannot find field ${type.name} in types`,
-            );
-          }
-          return PredicateValue.Operations.parse(json, subType, types);
-        }
-        if (type.kind == "union") {
-          const unionCase = type.args.get(json);
-          if (unionCase == undefined) {
-            return ValueOrErrors.Default.throwOne(
-              `Error: cannot find union case ${JSON.stringify(json)} in types`,
-            );
-          }
-          return PredicateValue.Operations.ParseAsUnionCase({
+};
+export const ValueFilterStartsWith = {
+    Default: (startsWith) => ({
+        kind: "startsWith",
+        startsWith,
+    }),
+};
+export const BinaryOperators = ["or", "equals"];
+export const BinaryOperatorsSet = Set(BinaryOperators);
+export const PredicateValue = {
+    Default: {
+        string: () => "",
+        number: () => 0,
+        boolean: () => false,
+        date: () => new Date(),
+        unit: () => ({ kind: "unit" }),
+        tuple: (values) => ({
+            kind: "tuple",
+            values,
+        }),
+        record: (fields) => ({
+            kind: "record",
+            fields,
+        }),
+        unionCase: (caseName, fields) => ({
             kind: "unionCase",
-            caseName: json,
-            value: { kind: "form", value: Map() },
-          });
-        }
-        if (type.kind == "application" && type.value == "List") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((elementValue) =>
-                PredicateValue.Operations.parse(
-                  elementValue,
-                  type.args[0],
-                  types,
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "application" && type.value == "Map") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((keyValue) =>
-                PredicateValue.Operations.parse(
-                  keyValue.key,
-                  type.args[0],
-                  types,
-                ).Then((key) =>
-                  PredicateValue.Operations.parse(
-                    keyValue.value,
-                    type === null || type === void 0 ? void 0 : type.args[1],
-                    types,
-                  ).Then((value) =>
-                    ValueOrErrors.Default.return(
-                      PredicateValue.Default.tuple(List([key, value])),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "application" && type.value == "Sum") {
-          return PredicateValue.Operations.parse(
-            json.left,
-            type === null || type === void 0 ? void 0 : type.args[0],
-            types,
-          ).Then((left) =>
-            PredicateValue.Operations.parse(
-              json.right,
-              type === null || type === void 0 ? void 0 : type.args[1],
-              types,
-            ).Then((right) =>
-              ValueOrErrors.Default.return(
-                PredicateValue.Default.tuple(List([left, right])),
-              ),
-            ),
-          );
-        }
-        if (type.kind == "application" && type.value == "SingleSelection") {
-          ValueOrErrors.Default.return(
-            PredicateValue.Default.option(json["IsSome"], json["Value"]),
-          );
-        }
-        if (type.kind == "application" && type.value == "MultiSelection") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((elementValue) =>
-                PredicateValue.Operations.parse(
-                  elementValue,
-                  type.args[0],
-                  types,
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "record") {
-          return ValueOrErrors.Operations.All(
-            List(
-              Object.entries(json).map(([fieldName, fieldValue]) => {
-                const subType = type.fields.get(fieldName);
-                if (subType == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `cannot find field ${fieldName} in type ${JSON.stringify(type)}`,
-                  );
-                }
-                return PredicateValue.Operations.parse(
-                  fieldValue,
-                  subType,
-                  types,
-                ).Then((value) =>
-                  ValueOrErrors.Default.return([fieldName, value]),
-                );
-              }),
-            ),
-          ).Then((entries) =>
-            ValueOrErrors.Default.return(
-              PredicateValue.Default.record(
-                OrderedMap(entries.map((_) => [_[0], _[1]])),
-              ),
-            ),
-          );
-        }
-        return ValueOrErrors.Default.throwOne(
-          `unsupported type ${JSON.stringify(type)}`,
-        );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When parsing expression ${JSON.stringify(json, null, 2)}`,
-        ),
-      );
-    },
-    recordToTuple: (r) => {
-      const valuesSortedByName = r.fields
-        .toSeq()
-        .map((v, k) => [k, v])
-        .sortBy(([k, v]) => k)
-        .map(([k, v]) => v)
-        .valueSeq()
-        .toArray();
-      return PredicateValue.Default.tuple(List(valuesSortedByName));
+            caseName,
+            fields,
+        }),
+        option: (isSome, value) => ({
+            kind: "option",
+            isSome,
+            value,
+        }),
+        varLookup: (varName) => ({
+            kind: "varLookup",
+            varName,
+        }),
+        sum: (value) => ({
+            kind: "sum",
+            value,
+        }),
+        sumN: (caseIndex, arity, value) => ({
+            kind: "sumN",
+            caseIndex,
+            arity,
+            value,
+        }),
+        table: (from, to, data, hasMoreValues) => ({
+            kind: "table",
+            from,
+            to,
+            data,
+            hasMoreValues,
+        }),
+        readonly: (value) => ({
+            kind: "readOnly",
+            ReadOnly: value,
+        }),
+        filterContains: (contains) => ({
+            kind: "contains",
+            contains,
+        }),
+        filterEqualsTo: (equalsTo) => ({
+            kind: "=",
+            equalsTo,
+        }),
+        filterNotEqualsTo: (notEqualsTo) => ({
+            kind: "!=",
+            notEqualsTo,
+        }),
+        filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
+            kind: ">=",
+            greaterThanOrEqualsTo,
+        }),
+        filterGreaterThan: (greaterThan) => ({
+            kind: ">",
+            greaterThan,
+        }),
+        filterIsNotNull: () => ({
+            kind: "!=null",
+        }),
+        filterIsNull: () => ({
+            kind: "=null",
+        }),
+        filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
+            kind: "<=",
+            smallerThanOrEqualsTo,
+        }),
+        filterSmallerThan: (smallerThan) => ({
+            kind: "<",
+            smallerThan,
+        }),
+        filterStartsWith: (startsWith) => ({
+            kind: "startsWith",
+            startsWith,
+        }),
     },
-    Equals: (vars) => (v1, v2) =>
-      typeof v1 == "boolean" ||
-      typeof v1 == "number" ||
-      typeof v1 == "string" ||
-      typeof v2 == "boolean" ||
-      typeof v2 == "number" ||
-      typeof v2 == "string"
-        ? typeof v1 == typeof v2
-          ? ValueOrErrors.Default.return(v1 == v2)
-          : ValueOrErrors.Default.throwOne(
-              `cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-            )
-        : PredicateValue.Operations.IsDate(v1) &&
-            PredicateValue.Operations.IsDate(v2)
-          ? v1.getTime() == v2.getTime()
-            ? ValueOrErrors.Default.return(true)
-            : ValueOrErrors.Default.return(false)
-          : PredicateValue.Operations.IsUnionCase(v1) &&
-              PredicateValue.Operations.IsUnionCase(v2)
-            ? v1.caseName == v2.caseName
-              ? PredicateValue.Operations.Equals(vars)(v1.fields, v2.fields)
-              : ValueOrErrors.Default.return(false)
-            : PredicateValue.Operations.IsTuple(v1) &&
-                PredicateValue.Operations.IsTuple(v2)
-              ? v1.values.size != v2.values.size
-                ? ValueOrErrors.Default.return(false)
-                : v1.values.size == 0
-                  ? ValueOrErrors.Default.return(true)
-                  : PredicateValue.Operations.Equals(vars)(
-                      v1.values.get(0),
-                      v2.values.get(0),
-                    ).Then((firstEqual) =>
-                      firstEqual
-                        ? PredicateValue.Operations.Equals(vars)(
-                            PredicateValue.Default.tuple(v1.values.slice(1)),
-                            PredicateValue.Default.tuple(v2.values.slice(1)),
-                          )
-                        : ValueOrErrors.Default.return(false),
-                    )
-              : PredicateValue.Operations.IsRecord(v1) &&
-                  PredicateValue.Operations.IsRecord(v2)
-                ? PredicateValue.Operations.Equals(vars)(
-                    PredicateValue.Operations.recordToTuple(v1),
-                    PredicateValue.Operations.recordToTuple(v2),
-                  )
-                : PredicateValue.Operations.IsTable(v1) &&
-                    PredicateValue.Operations.IsTable(v2)
-                  ? v1.data.size == v2.data.size
-                    ? ValueOrErrors.Default.return(
-                        v1.data.keySeq().equals(v2.data.keySeq()),
-                      )
-                    : ValueOrErrors.Default.return(false)
-                  : PredicateValue.Operations.IsUnit(v1) &&
-                      PredicateValue.Operations.IsUnit(v2)
+    Operations: {
+        GetKind: (value) => typeof value == "object"
+            ? "kind" in value
+                ? ValueOrErrors.Default.return(value.kind)
+                : PredicateValue.Operations.IsDate(value)
+                    ? ValueOrErrors.Default.return("date")
+                    : ValueOrErrors.Default.throwOne("invalid")
+            : ValueOrErrors.Default.return(typeof value),
+        IsPrimitive: (value) => {
+            return (PredicateValue.Operations.IsBoolean(value) ||
+                PredicateValue.Operations.IsNumber(value) ||
+                PredicateValue.Operations.IsString(value) ||
+                PredicateValue.Operations.IsDate(value));
+        },
+        IsBoolean: (value) => {
+            return typeof value == "boolean";
+        },
+        IsNumber: (value) => {
+            return typeof value == "number";
+        },
+        IsString: (value) => {
+            return typeof value == "string";
+        },
+        IsDate: (value) => {
+            return (typeof value == "object" &&
+                Object.prototype.toString.call(value) === "[object Date]" &&
+                value instanceof Date &&
+                !isNaN(value.getTime()));
+        },
+        IsUnit: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "unit");
+        },
+        IsUnionCase: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "unionCase");
+        },
+        IsRecord: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "record");
+        },
+        IsTuple: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "tuple");
+        },
+        IsOption: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "option");
+        },
+        IsTable: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "table");
+        },
+        IsSum: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "sum");
+        },
+        IsSumN: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "sumN");
+        },
+        IsVarLookup: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "varLookup");
+        },
+        IsCustom: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "custom");
+        },
+        IsReadOnly: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "readOnly");
+        },
+        IsFilterContains: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "contains");
+        },
+        IsFilterEqualsTo: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "=");
+        },
+        IsFilterNotEqualsTo: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "!=");
+        },
+        IsFilterGreaterThanOrEqualsTo: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == ">=");
+        },
+        IsFilterGreaterThan: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == ">");
+        },
+        IsFilterIsNotNull: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "!=null");
+        },
+        IsFilterIsNull: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "=null");
+        },
+        IsFilterSmallerThanOrEqualsTo: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "<=");
+        },
+        IsFilterSmallerThan: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "<");
+        },
+        IsFilterStartsWith: (value) => {
+            return (typeof value == "object" &&
+                !PredicateValue.Operations.IsDate(value) &&
+                value.kind == "startsWith");
+        },
+        KindAndValueToFilter: (kind, value) => {
+            switch (kind) {
+                case "contains":
+                    return PredicateValue.Default.filterContains(value);
+                case "=":
+                    return PredicateValue.Default.filterEqualsTo(value);
+                case "!=":
+                    return PredicateValue.Default.filterNotEqualsTo(value);
+                case ">=":
+                    return PredicateValue.Default.filterGreaterThanOrEqualsTo(value);
+                case ">":
+                    return PredicateValue.Default.filterGreaterThan(value);
+                case "!=null":
+                    return PredicateValue.Default.filterIsNotNull();
+                case "=null":
+                    return PredicateValue.Default.filterIsNull();
+                case "<=":
+                    return PredicateValue.Default.filterSmallerThanOrEqualsTo(value);
+                case "<":
+                    return PredicateValue.Default.filterSmallerThan(value);
+                case "startsWith":
+                    return PredicateValue.Default.filterStartsWith(value);
+                default:
+                    return PredicateValue.Default.filterEqualsTo(value);
+            }
+        },
+        FilterToKindAndValue: (filter) => {
+            switch (filter.kind) {
+                case "contains":
+                    return { kind: "contains", value: filter.contains };
+                case "=":
+                    return { kind: "=", value: filter.equalsTo };
+                case "!=":
+                    return { kind: "!=", value: filter.notEqualsTo };
+                case ">=":
+                    return { kind: ">=", value: filter.greaterThanOrEqualsTo };
+                case ">":
+                    return { kind: ">", value: filter.greaterThan };
+                case "!=null":
+                    return { kind: "!=null", value: PredicateValue.Default.unit() };
+                case "=null":
+                    return { kind: "=null", value: PredicateValue.Default.unit() };
+                case "<=":
+                    return { kind: "<=", value: filter.smallerThanOrEqualsTo };
+                case "<":
+                    return { kind: "<", value: filter.smallerThan };
+                default:
+                    return { kind: "startsWith", value: filter.startsWith };
+            }
+        },
+        ParseAsDate: (json) => {
+            if (PredicateValue.Operations.IsDate(json))
+                return ValueOrErrors.Default.return(json);
+            return ValueOrErrors.Default.throwOne(`date has invalid value property`);
+        },
+        ParseAsVarLookup: (json) => {
+            if (json.kind == "varLookup" && typeof json.varName == "string")
+                return ValueOrErrors.Default.return(PredicateValue.Default.varLookup(json.varName));
+            return ValueOrErrors.Default.throwOne(`varLookup has invalid varName property`);
+        },
+        ParseAsUnionCase: (json) => {
+            if (typeof json.caseName == "string")
+                return ValueOrErrors.Default.return(PredicateValue.Default.unionCase(json.caseName, json.value));
+            return ValueOrErrors.Default.throwOne(`union case has invalid caseName property`);
+        },
+        ParseAsRecord: (json, types) => {
+            if ("fields" in json && typeof json.fields == "object") {
+                return ValueOrErrors.Operations.All(List(Object.entries(json.fields).map(([fieldName, fieldValue]) => PredicateValue.Operations.parse(fieldValue, { kind: "expression" }, types).Then((value) => ValueOrErrors.Default.return([fieldName, value]))))).Then((entries) => ValueOrErrors.Default.return(PredicateValue.Default.record(OrderedMap(entries))));
+            }
+            return ValueOrErrors.Default.throwOne(`record has no field property`);
+        },
+        ParseAsTuple: (json, types) => {
+            if (json.values != undefined && Array.isArray(json.values)) {
+                return ValueOrErrors.Operations.All(List(json.values.map((elementValue) => PredicateValue.Operations.parse(elementValue, { kind: "expression" }, types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
+            }
+            return ValueOrErrors.Default.throwOne(`Error: tuple has no values property`);
+        },
+        // TODO -- do we need to add table here ?
+        parse: (json, type, types) => {
+            const result = (() => {
+                if (type.kind == "expression" &&
+                    (typeof json == "boolean" ||
+                        typeof json == "number" ||
+                        typeof json == "string"))
+                    return ValueOrErrors.Default.return(json);
+                if (type.kind == "expression" && json.kind == undefined) {
+                    return ValueOrErrors.Default.throwOne(`evaluation statement has no kind value`);
+                }
+                if (type.kind == "expression" && json.kind == "guid") {
+                    return ValueOrErrors.Default.return(json);
+                }
+                if (type.kind == "expression" && json.kind == "date") {
+                    return PredicateValue.Operations.ParseAsDate(json);
+                }
+                if (type.kind == "expression" && json.kind == "unit") {
+                    return ValueOrErrors.Default.return(PredicateValue.Default.unit());
+                }
+                if (type.kind == "expression" && json.kind == "varLookup") {
+                    return PredicateValue.Operations.ParseAsVarLookup(json);
+                }
+                if (type.kind == "expression" &&
+                    json.kind == "record" &&
+                    "caseName" in json) {
+                    return PredicateValue.Operations.ParseAsUnionCase(json);
+                }
+                if (type.kind == "expression" &&
+                    json.kind == "record" &&
+                    "fields" in json) {
+                    return PredicateValue.Operations.ParseAsRecord(json, types);
+                }
+                if (type.kind == "expression" &&
+                    json.kind == "tuple" &&
+                    "values" in json) {
+                    return PredicateValue.Operations.ParseAsTuple(json, types);
+                }
+                if (type.kind == "primitive" && type.value == "Date") {
+                    if (PredicateValue.Operations.IsDate(json)) {
+                        return ValueOrErrors.Default.return(json);
+                    }
+                    return ValueOrErrors.Default.throwOne(`failed to parse date ${JSON.stringify(json)}`);
+                }
+                if (type.kind == "primitive" && type.value == "maybeBoolean") {
+                    return json == undefined
+                        ? ValueOrErrors.Default.return(false)
+                        : ValueOrErrors.Default.return(json);
+                }
+                if (type.kind == "primitive") {
+                    return ValueOrErrors.Default.return(json);
+                }
+                if (type.kind == "lookup") {
+                    const subType = types.get(type.name);
+                    if (subType == undefined) {
+                        return ValueOrErrors.Default.throwOne(`cannot find field ${type.name} in types`);
+                    }
+                    return PredicateValue.Operations.parse(json, subType, types);
+                }
+                if (type.kind == "union") {
+                    const unionCase = type.args.get(json);
+                    if (unionCase == undefined) {
+                        return ValueOrErrors.Default.throwOne(`Error: cannot find union case ${JSON.stringify(json)} in types`);
+                    }
+                    return PredicateValue.Operations.ParseAsUnionCase({
+                        kind: "unionCase",
+                        caseName: json,
+                        value: { kind: "form", value: Map() },
+                    });
+                }
+                if (type.kind == "application" && type.value == "List") {
+                    return ValueOrErrors.Operations.All(List(json.map((elementValue) => PredicateValue.Operations.parse(elementValue, type.args[0], types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
+                }
+                if (type.kind == "application" && type.value == "Map") {
+                    return ValueOrErrors.Operations.All(List(json.map((keyValue) => PredicateValue.Operations.parse(keyValue.key, type.args[0], types).Then((key) => PredicateValue.Operations.parse(keyValue.value, type === null || type === void 0 ? void 0 : type.args[1], types).Then((value) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(List([key, value])))))))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
+                }
+                if (type.kind == "application" && type.value == "Sum") {
+                    return PredicateValue.Operations.parse(json.left, type === null || type === void 0 ? void 0 : type.args[0], types).Then((left) => PredicateValue.Operations.parse(json.right, type === null || type === void 0 ? void 0 : type.args[1], types).Then((right) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(List([left, right])))));
+                }
+                if (type.kind == "application" && type.value == "SingleSelection") {
+                    ValueOrErrors.Default.return(PredicateValue.Default.option(json["IsSome"], json["Value"]));
+                }
+                if (type.kind == "application" && type.value == "MultiSelection") {
+                    return ValueOrErrors.Operations.All(List(json.map((elementValue) => PredicateValue.Operations.parse(elementValue, type.args[0], types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
+                }
+                if (type.kind == "record") {
+                    return ValueOrErrors.Operations.All(List(Object.entries(json).map(([fieldName, fieldValue]) => {
+                        const subType = type.fields.get(fieldName);
+                        if (subType == undefined) {
+                            return ValueOrErrors.Default.throwOne(`cannot find field ${fieldName} in type ${JSON.stringify(type)}`);
+                        }
+                        return PredicateValue.Operations.parse(fieldValue, subType, types).Then((value) => ValueOrErrors.Default.return([fieldName, value]));
+                    }))).Then((entries) => ValueOrErrors.Default.return(PredicateValue.Default.record(OrderedMap(entries.map((_) => [_[0], _[1]])))));
+                }
+                return ValueOrErrors.Default.throwOne(`unsupported type ${JSON.stringify(type)}`);
+            })();
+            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When parsing expression ${JSON.stringify(json, null, 2)}`));
+        },
+        recordToTuple: (r) => {
+            const valuesSortedByName = r.fields
+                .toSeq()
+                .map((v, k) => [k, v])
+                .sortBy(([k, v]) => k)
+                .map(([k, v]) => v)
+                .valueSeq()
+                .toArray();
+            return PredicateValue.Default.tuple(List(valuesSortedByName));
+        },
+        Equals: (vars) => (v1, v2) => typeof v1 == "boolean" ||
+            typeof v1 == "number" ||
+            typeof v1 == "string" ||
+            typeof v2 == "boolean" ||
+            typeof v2 == "number" ||
+            typeof v2 == "string"
+            ? typeof v1 == typeof v2
+                ? ValueOrErrors.Default.return(v1 == v2)
+                : ValueOrErrors.Default.throwOne(`cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`)
+            : PredicateValue.Operations.IsDate(v1) &&
+                PredicateValue.Operations.IsDate(v2)
+                ? v1.getTime() == v2.getTime()
                     ? ValueOrErrors.Default.return(true)
-                    : PredicateValue.Operations.IsUnit(v1) !=
-                        PredicateValue.Operations.IsUnit(v2)
-                      ? ValueOrErrors.Default.throwOne(
-                          `cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-                        )
-                      : ValueOrErrors.Default.throwOne(
-                          `structural equality is not implemented yet between ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-                        ),
-  },
+                    : ValueOrErrors.Default.return(false)
+                : PredicateValue.Operations.IsUnionCase(v1) &&
+                    PredicateValue.Operations.IsUnionCase(v2)
+                    ? v1.caseName == v2.caseName
+                        ? PredicateValue.Operations.Equals(vars)(v1.fields, v2.fields)
+                        : ValueOrErrors.Default.return(false)
+                    : PredicateValue.Operations.IsTuple(v1) &&
+                        PredicateValue.Operations.IsTuple(v2)
+                        ? v1.values.size != v2.values.size
+                            ? ValueOrErrors.Default.return(false)
+                            : v1.values.size == 0
+                                ? ValueOrErrors.Default.return(true)
+                                : PredicateValue.Operations.Equals(vars)(v1.values.get(0), v2.values.get(0)).Then((firstEqual) => firstEqual
+                                    ? PredicateValue.Operations.Equals(vars)(PredicateValue.Default.tuple(v1.values.slice(1)), PredicateValue.Default.tuple(v2.values.slice(1)))
+                                    : ValueOrErrors.Default.return(false))
+                        : PredicateValue.Operations.IsRecord(v1) &&
+                            PredicateValue.Operations.IsRecord(v2)
+                            ? PredicateValue.Operations.Equals(vars)(PredicateValue.Operations.recordToTuple(v1), PredicateValue.Operations.recordToTuple(v2))
+                            : PredicateValue.Operations.IsTable(v1) &&
+                                PredicateValue.Operations.IsTable(v2)
+                                ? v1.data.size == v2.data.size
+                                    ? ValueOrErrors.Default.return(v1.data.keySeq().equals(v2.data.keySeq()))
+                                    : ValueOrErrors.Default.return(false)
+                                : PredicateValue.Operations.IsUnit(v1) &&
+                                    PredicateValue.Operations.IsUnit(v2)
+                                    ? ValueOrErrors.Default.return(true)
+                                    : PredicateValue.Operations.IsUnit(v1) !=
+                                        PredicateValue.Operations.IsUnit(v2)
+                                        ? ValueOrErrors.Default.throwOne(`cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`)
+                                        : ValueOrErrors.Default.throwOne(`structural equality is not implemented yet between ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`),
+    },
 };
 export const Expr = {
-  Default: {
-    itemLookup: (e, i) => ({
-      kind: "itemLookup",
-      operands: [e, i],
-    }),
-    fieldLookup: (e, f) => ({
-      kind: "fieldLookup",
-      operands: [e, f],
-    }),
-    isCase: (e, c) => ({
-      kind: "isCase",
-      operands: [e, c],
-    }),
-    binaryOperator: (op, e1, e2) => ({
-      kind: op,
-      operands: [e1, e2],
-    }),
-    matchCase: (operands) => ({
-      kind: "matchCase",
-      operands,
-    }),
-    lambda: (parameter, body) => ({
-      kind: "lambda",
-      parameter,
-      body,
-    }),
-    case: (caseName, handler) => ({
-      kind: "caseName",
-      caseName,
-      handler,
-    }),
-  },
-  Operations: {
-    IsItemLookup: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "itemLookup"
-      );
-    },
-    IsFieldLookup: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "fieldLookup"
-      );
-    },
-    IsIsCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "isCase"
-      );
-    },
-    IsBinaryOperator: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        BinaryOperatorsSet.has(e.kind)
-      );
-    },
-    IsCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "caseName"
-      );
-    },
-    IsCaseArray: (e) => {
-      return e.every((e) => Expr.Operations.IsCase(e));
-    },
-    AsCaseArray: (e) => {
-      return e.every((e) => Expr.Operations.IsCase(e))
-        ? ValueOrErrors.Default.return(e)
-        : ValueOrErrors.Default.throwOne(
-            `Error: expected cases, got ${JSON.stringify(e)}`,
-          );
-    },
-    IsMatchCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "matchCase"
-      );
-    },
-    IsLambda: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "lambda"
-      );
-    },
-    parseAsVisibilityExpression: (json) =>
-      Expr.Operations.parse(json).MapErrors((errors) =>
-        errors.map(
-          (error) => `${error}\n...When parsing visibility expression`,
-        ),
-      ),
-    parseAsDisabledExpression: (json) =>
-      Expr.Operations.parse(json).MapErrors((errors) =>
-        errors.map((error) => `${error}\n...When parsing disabled expression`),
-      ),
-    parse: (json) => {
-      const asValue = PredicateValue.Operations.parse(
-        json,
-        { kind: "expression" },
-        Map(),
-      );
-      if (asValue.kind == "value") return asValue;
-      if (Expr.Operations.IsItemLookup(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(
-            // Tuples are 1-indexed
-            Expr.Default.itemLookup(first, second - 1),
-          ),
-        );
-      }
-      if (Expr.Operations.IsFieldLookup(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(Expr.Default.fieldLookup(first, second)),
-        );
-      }
-      if (Expr.Operations.IsIsCase(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(Expr.Default.isCase(first, second)),
-        );
-      }
-      if (Expr.Operations.IsBinaryOperator(json)) {
-        const [first, second] = json["operands"];
-        if (BinaryOperatorsSet.contains(json["kind"])) {
-          return Expr.Operations.parse(first).Then((first) =>
-            Expr.Operations.parse(second).Then((second) =>
-              ValueOrErrors.Default.return(
-                Expr.Default.binaryOperator(json["kind"], first, second),
-              ),
-            ),
-          );
-        }
-      }
-      if (Expr.Operations.IsMatchCase(json)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            json["operands"].map((operand) => Expr.Operations.parse(operand)),
-          ),
-        ).Then((operands) =>
-          ValueOrErrors.Default.return(
-            Expr.Default.matchCase(operands.toArray()),
-          ),
-        );
-      }
-      if (Expr.Operations.IsLambda(json)) {
-        return Expr.Operations.parse(json["body"]).Then((body) =>
-          ValueOrErrors.Default.return(
-            Expr.Default.lambda(json["parameter"], body),
-          ),
-        );
-      }
-      if (Expr.Operations.IsCase(json)) {
-        return Expr.Operations.parse(json["handler"]).Then((handler) =>
-          Expr.Operations.IsLambda(handler)
-            ? ValueOrErrors.Default.return(
-                Expr.Default.case(json["caseName"], handler),
-              )
-            : ValueOrErrors.Default.throwOne(
-                `expected lambda expression, got ${JSON.stringify(handler)}`,
-              ),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(
-        `cannot parse ${JSON.stringify(json)} to Expr.`,
-      );
-    },
-    EvaluateAsTuple: (vars) => (e) =>
-      !PredicateValue.Operations.IsTuple(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected tuple expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsRecord: (vars) => (e) =>
-      !PredicateValue.Operations.IsRecord(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected record expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsUnionCase: (vars) => (e) =>
-      !PredicateValue.Operations.IsUnionCase(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected union case expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsBoolean: (vars) => (e) =>
-      !PredicateValue.Operations.IsBoolean(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected boolean expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    MatchCase: (vars) => (e, cases) =>
-      Expr.Operations.Evaluate(vars)(e).Then((matchable) =>
-        PredicateValue.Operations.IsSum(matchable)
-          ? matchable.value.kind == "l"
-            ? MapRepo.Operations.tryFindWithError(
-                "Sum.Left",
-                cases,
-                () => `cannot find match case Sum.Left`,
-              ).Then((leftCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(leftCaseHandler.parameter, matchable.value.value),
-                )(leftCaseHandler),
-              )
-            : MapRepo.Operations.tryFindWithError(
-                "Sum.Right",
-                cases,
-                () => `cannot find match case Sum.Right`,
-              ).Then((rightCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(rightCaseHandler.parameter, matchable.value.value),
-                )(rightCaseHandler),
-              )
-          : PredicateValue.Operations.IsUnionCase(matchable)
-            ? MapRepo.Operations.tryFindWithError(
-                matchable.caseName,
-                cases,
-                () => `cannot find match case ${matchable.caseName}`,
-              ).Then((matchedCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(matchedCaseHandler.parameter, matchable.fields),
-                )(matchedCaseHandler),
-              )
-            : ValueOrErrors.Default.throwOne(
-                `unsupported matchable type in MatchCase: ${JSON.stringify(matchable)}`,
-              ),
-      ),
-    ComputePredicateEvaluation: (vars) => (expr) => {
-      if (typeof expr == "boolean") {
-        return ValueOrErrors.Default.return(expr);
-      }
-      return Expr.Operations.Evaluate(vars)(expr).Then((result) => {
-        if (typeof result == "boolean") {
-          return ValueOrErrors.Default.return(result);
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`,
-        );
-      });
-    },
-    EvaluateAs: (as) => (vars) => (e) => {
-      return Expr.Operations.Evaluate(vars)(e).MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When evaluating expression ${JSON.stringify(e)} as ${as}`,
-        ),
-      );
+    Default: {
+        prepend: (prependCases, e) => ({
+            kind: "prepend",
+            operands: [prependCases, e],
+        }),
+        itemLookup: (e, i) => ({
+            kind: "itemLookup",
+            operands: [e, i],
+        }),
+        fieldLookup: (e, f) => ({
+            kind: "fieldLookup",
+            operands: [e, f],
+        }),
+        isCase: (e, c) => ({
+            kind: "isCase",
+            operands: [e, c],
+        }),
+        binaryOperator: (op, e1, e2) => ({
+            kind: op,
+            operands: [e1, e2],
+        }),
+        matchCase: (operands) => ({
+            kind: "matchCase",
+            operands,
+        }),
+        lambda: (parameter, body) => ({
+            kind: "lambda",
+            parameter,
+            body,
+        }),
+        case: (caseName, handler) => ({
+            kind: "caseName",
+            caseName,
+            handler,
+        }),
     },
-    Evaluate: (vars) => (e) => {
-      const result = (() => {
-        return PredicateValue.Operations.IsBoolean(e) ||
-          PredicateValue.Operations.IsNumber(e) ||
-          PredicateValue.Operations.IsString(e) ||
-          PredicateValue.Operations.IsUnit(e) ||
-          PredicateValue.Operations.IsRecord(e) ||
-          PredicateValue.Operations.IsTuple(e) ||
-          PredicateValue.Operations.IsUnionCase(e) ||
-          PredicateValue.Operations.IsUnit(e) ||
-          PredicateValue.Operations.IsSum(e)
-          ? ValueOrErrors.Default.return(e)
-          : PredicateValue.Operations.IsVarLookup(e)
-            ? MapRepo.Operations.tryFindWithError(
-                e.varName,
-                vars,
-                () =>
-                  `Error: cannot find variable ${JSON.stringify(e.varName)}`,
-              )
-            : Expr.Operations.IsItemLookup(e)
-              ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                  (maybeTuple) =>
-                    Expr.Operations.EvaluateAsTuple(vars)(maybeTuple).Then(
-                      (tuple) =>
-                        ListRepo.Operations.tryFindWithError(
-                          e.operands[1],
-                          tuple.values,
-                          () =>
-                            `Error: cannot find element of index ${e.operands[1]} in tuple ${JSON.stringify(tuple)}`,
-                        ),
-                    ),
-                )
-              : Expr.Operations.IsFieldLookup(e)
-                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                    (maybeRecord) =>
-                      Expr.Operations.EvaluateAsRecord(vars)(maybeRecord).Then(
-                        (record) =>
-                          MapRepo.Operations.tryFindWithError(
-                            e.operands[1],
-                            record.fields,
-                            () => `Error: cannot find field ${e.operands[1]}`,
-                          ),
-                      ),
-                  )
-                : Expr.Operations.IsIsCase(e)
-                  ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                      (maybeUnionCase) =>
-                        Expr.Operations.EvaluateAsUnionCase(vars)(
-                          maybeUnionCase,
-                        ).Then((unionCase) =>
-                          ValueOrErrors.Default.return(
-                            unionCase.caseName == e.operands[1],
-                          ),
-                        ),
-                    )
-                  : Expr.Operations.IsMatchCase(e)
-                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                        (matchable) =>
-                          Expr.Operations.AsCaseArray(e.operands.slice(1)).Then(
-                            (cases) =>
-                              Expr.Operations.MatchCase(vars)(
-                                matchable,
-                                Map(cases.map((c) => [c.caseName, c.handler])),
-                              ),
-                          ),
-                      )
-                    : Expr.Operations.IsLambda(e)
-                      ? Expr.Operations.Evaluate(vars)(e.body)
-                      : Expr.Operations.IsBinaryOperator(e) &&
-                          e.kind == "equals"
-                        ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                            (v1) =>
-                              Expr.Operations.Evaluate(vars)(
-                                e.operands[1],
-                              ).Then((v2) =>
-                                PredicateValue.Operations.Equals(vars)(
-                                  v1,
-                                  v2,
-                                ).Then((eq) =>
-                                  ValueOrErrors.Default.return(eq),
-                                ),
-                              ),
-                          )
-                        : Expr.Operations.IsBinaryOperator(e) && e.kind == "or"
-                          ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                              (v1) =>
-                                Expr.Operations.Evaluate(vars)(
-                                  e.operands[1],
-                                ).Then((v2) =>
-                                  Expr.Operations.EvaluateAsBoolean(vars)(
-                                    v1,
-                                  ).Then((v1) =>
-                                    Expr.Operations.EvaluateAsBoolean(vars)(
-                                      v2,
-                                    ).Then((v2) =>
-                                      ValueOrErrors.Default.return(v1 || v2),
-                                    ),
-                                  ),
-                                ),
-                            )
-                          : ValueOrErrors.Default.throwOne(
-                              `Error: unsupported expression ${JSON.stringify(e)}`,
-                            );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When evaluating expression ${JSON.stringify(e, null, 2)}`,
-        ),
-      );
+    Operations: {
+        IsPrepend: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "prepend");
+        },
+        IsItemLookup: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "itemLookup");
+        },
+        IsFieldLookup: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "fieldLookup");
+        },
+        IsIsCase: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "isCase");
+        },
+        IsBinaryOperator: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                BinaryOperatorsSet.has(e.kind));
+        },
+        IsCase: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "caseName");
+        },
+        IsCaseArray: (e) => {
+            return e.every((e) => Expr.Operations.IsCase(e));
+        },
+        AsCaseArray: (e) => {
+            return e.every((e) => Expr.Operations.IsCase(e))
+                ? ValueOrErrors.Default.return(e)
+                : ValueOrErrors.Default.throwOne(`Error: expected cases, got ${JSON.stringify(e)}`);
+        },
+        IsMatchCase: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "matchCase");
+        },
+        IsLambda: (e) => {
+            return (typeof e == "object" &&
+                !PredicateValue.Operations.IsDate(e) &&
+                e.kind == "lambda");
+        },
+        parseAsVisibilityExpression: (json) => Expr.Operations.parse(json).MapErrors((errors) => errors.map((error) => `${error}\n...When parsing visibility expression`)),
+        parseAsDisabledExpression: (json) => Expr.Operations.parse(json).MapErrors((errors) => errors.map((error) => `${error}\n...When parsing disabled expression`)),
+        parse: (json) => {
+            const asValue = PredicateValue.Operations.parse(json, { kind: "expression" }, Map());
+            if (asValue.kind == "value")
+                return asValue;
+            if (Expr.Operations.IsItemLookup(json)) {
+                const [first, second] = json["operands"];
+                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(
+                // Tuples are 1-indexed
+                Expr.Default.itemLookup(first, second - 1)));
+            }
+            if (Expr.Operations.IsFieldLookup(json)) {
+                const [first, second] = json["operands"];
+                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(Expr.Default.fieldLookup(first, second)));
+            }
+            if (Expr.Operations.IsIsCase(json)) {
+                const [first, second] = json["operands"];
+                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(Expr.Default.isCase(first, second)));
+            }
+            if (Expr.Operations.IsBinaryOperator(json)) {
+                const [first, second] = json["operands"];
+                if (BinaryOperatorsSet.contains(json["kind"])) {
+                    return Expr.Operations.parse(first).Then((first) => Expr.Operations.parse(second).Then((second) => ValueOrErrors.Default.return(Expr.Default.binaryOperator(json["kind"], first, second))));
+                }
+            }
+            if (Expr.Operations.IsMatchCase(json)) {
+                return ValueOrErrors.Operations.All(List(json["operands"].map((operand) => Expr.Operations.parse(operand)))).Then((operands) => ValueOrErrors.Default.return(Expr.Default.matchCase(operands.toArray())));
+            }
+            if (Expr.Operations.IsLambda(json)) {
+                return Expr.Operations.parse(json["body"]).Then((body) => ValueOrErrors.Default.return(Expr.Default.lambda(json["parameter"], body)));
+            }
+            if (Expr.Operations.IsCase(json)) {
+                return Expr.Operations.parse(json["handler"]).Then((handler) => Expr.Operations.IsLambda(handler)
+                    ? ValueOrErrors.Default.return(Expr.Default.case(json["caseName"], handler))
+                    : ValueOrErrors.Default.throwOne(`expected lambda expression, got ${JSON.stringify(handler)}`));
+            }
+            if (Expr.Operations.IsPrepend(json)) {
+                const [casesToPrepend, expr] = json["operands"];
+                return Expr.Operations.parse(expr).Then((expr) => ValueOrErrors.Default.return(Expr.Default.prepend(casesToPrepend, expr)));
+            }
+            return ValueOrErrors.Default.throwOne(`cannot parse ${JSON.stringify(json)} to Expr.`);
+        },
+        EvaluateAsTuple: (vars) => (e) => !PredicateValue.Operations.IsTuple(e)
+            ? ValueOrErrors.Default.throwOne(`expected tuple expression, got ${JSON.stringify(e)}`)
+            : ValueOrErrors.Default.return(e),
+        EvaluateAsRecord: (vars) => (e) => !PredicateValue.Operations.IsRecord(e)
+            ? ValueOrErrors.Default.throwOne(`expected record expression, got ${JSON.stringify(e)}`)
+            : ValueOrErrors.Default.return(e),
+        EvaluateAsUnionCase: (vars) => (e) => !PredicateValue.Operations.IsUnionCase(e)
+            ? ValueOrErrors.Default.throwOne(`expected union case expression, got ${JSON.stringify(e)}`)
+            : ValueOrErrors.Default.return(e),
+        EvaluateAsBoolean: (vars) => (e) => !PredicateValue.Operations.IsBoolean(e)
+            ? ValueOrErrors.Default.throwOne(`expected boolean expression, got ${JSON.stringify(e)}`)
+            : ValueOrErrors.Default.return(e),
+        MatchCase: (vars) => (e, cases) => Expr.Operations.Evaluate(vars)(e).Then((matchable) => PredicateValue.Operations.IsSum(matchable)
+            ? matchable.value.kind == "l"
+                ? MapRepo.Operations.tryFindWithError("Sum.Left", cases, () => `cannot find match case Sum.Left`).Then((leftCaseHandler) => Expr.Operations.Evaluate(vars.set(leftCaseHandler.parameter, matchable.value.value))(leftCaseHandler))
+                : MapRepo.Operations.tryFindWithError("Sum.Right", cases, () => `cannot find match case Sum.Right`).Then((rightCaseHandler) => Expr.Operations.Evaluate(vars.set(rightCaseHandler.parameter, matchable.value.value))(rightCaseHandler))
+            : PredicateValue.Operations.IsUnionCase(matchable)
+                ? MapRepo.Operations.tryFindWithError(matchable.caseName, cases, () => `cannot find match case ${matchable.caseName}`).Then((matchedCaseHandler) => Expr.Operations.Evaluate(vars.set(matchedCaseHandler.parameter, matchable.fields))(matchedCaseHandler))
+                : ValueOrErrors.Default.throwOne(`unsupported matchable type in MatchCase: ${JSON.stringify(matchable)}`)),
+        ComputePredicateEvaluation: (vars) => (expr) => {
+            if (typeof expr == "boolean") {
+                return ValueOrErrors.Default.return(expr);
+            }
+            return Expr.Operations.Evaluate(vars)(expr).Then((result) => {
+                if (typeof result == "boolean") {
+                    return ValueOrErrors.Default.return(result);
+                }
+                return ValueOrErrors.Default.throwOne(`Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`);
+            });
+        },
+        EvaluateAs: (as) => (vars) => (e) => {
+            return Expr.Operations.Evaluate(vars)(e).MapErrors((errors) => errors.map((error) => `${error}\n...When evaluating expression ${JSON.stringify(e)} as ${as}`));
+        },
+        Evaluate: (vars) => (e) => {
+            const result = (() => {
+                return PredicateValue.Operations.IsBoolean(e) ||
+                    PredicateValue.Operations.IsNumber(e) ||
+                    PredicateValue.Operations.IsString(e) ||
+                    PredicateValue.Operations.IsUnit(e) ||
+                    PredicateValue.Operations.IsRecord(e) ||
+                    PredicateValue.Operations.IsTuple(e) ||
+                    PredicateValue.Operations.IsUnionCase(e) ||
+                    PredicateValue.Operations.IsSum(e)
+                    ? ValueOrErrors.Default.return(e)
+                    : PredicateValue.Operations.IsVarLookup(e)
+                        ? MapRepo.Operations.tryFindWithError(e.varName, vars, () => `Error: cannot find variable ${JSON.stringify(e.varName)}`)
+                        : Expr.Operations.IsItemLookup(e)
+                            ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeTuple) => Expr.Operations.EvaluateAsTuple(vars)(maybeTuple).Then((tuple) => ListRepo.Operations.tryFindWithError(e.operands[1], tuple.values, () => `Error: cannot find element of index ${e.operands[1]} in tuple ${JSON.stringify(tuple)}`)))
+                            : Expr.Operations.IsFieldLookup(e)
+                                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeRecord) => Expr.Operations.EvaluateAsRecord(vars)(maybeRecord).Then((record) => MapRepo.Operations.tryFindWithError(e.operands[1], record.fields, () => `Error: cannot find field ${e.operands[1]}`)))
+                                : Expr.Operations.IsIsCase(e)
+                                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeUnionCase) => Expr.Operations.EvaluateAsUnionCase(vars)(maybeUnionCase).Then((unionCase) => ValueOrErrors.Default.return(unionCase.caseName == e.operands[1])))
+                                    : Expr.Operations.IsMatchCase(e)
+                                        ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((matchable) => Expr.Operations.AsCaseArray(e.operands.slice(1)).Then((cases) => Expr.Operations.MatchCase(vars)(matchable, Map(cases.map((c) => [c.caseName, c.handler])))))
+                                        : Expr.Operations.IsLambda(e)
+                                            ? Expr.Operations.Evaluate(vars)(e.body)
+                                            : Expr.Operations.IsBinaryOperator(e) &&
+                                                e.kind == "equals"
+                                                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) => Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v2) => PredicateValue.Operations.Equals(vars)(v1, v2).Then((eq) => ValueOrErrors.Default.return(eq))))
+                                                : Expr.Operations.IsBinaryOperator(e) &&
+                                                    e.kind == "or"
+                                                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) => Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v2) => Expr.Operations.EvaluateAsBoolean(vars)(v1).Then((v1) => Expr.Operations.EvaluateAsBoolean(vars)(v2).Then((v2) => ValueOrErrors.Default.return(v1 || v2)))))
+                                                    : Expr.Operations.IsPrepend(e)
+                                                        ? Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v) => Expr.Operations.EvaluateAsRecord(vars)(v).Then((v) => {
+                                                            const prependEntries = e.operands[0].map((c) => [
+                                                                c,
+                                                                PredicateValue.Default.record(OrderedMap([["Value", c]])),
+                                                            ]);
+                                                            const existingEntries = Array.from(v.fields.entries());
+                                                            let returnValue = PredicateValue.Default.record(OrderedMap(prependEntries.concat(existingEntries)));
+                                                            return ValueOrErrors.Default.return(returnValue);
+                                                        }))
+                                                        : ValueOrErrors.Default.throwOne(`Error: unsupported expression ${JSON.stringify(e)}`);
+            })();
+            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When evaluating expression ${JSON.stringify(e, null, 2)}`));
+        },
     },
-  },
 };
 export const evaluatePredicates = (context, root) => {
-  const bindings = Map()
-    .set("global", context.global)
-    .set("root", root)
-    .set("local", root);
-  const traverse = (bindings, predicate, raw) => {
-    if (predicate.kind == "primitive") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        return ValueOrErrors.Default.return({
-          kind: "primitive",
-          value: result,
-        });
-      });
-    }
-    if (predicate.kind == "record") {
-      if (typeof raw != "object" || !("kind" in raw) || raw.kind != "record") {
-        return ValueOrErrors.Default.throwOne(
-          `parsing expected record in raw, got ${JSON.stringify(raw)}`,
-        );
-      }
-      return calculateVisibility(predicate.value, bindings).Then((result) =>
-        ValueOrErrors.Operations.All(
-          List(
-            predicate.fields.entrySeq().map(([fieldName, fieldPredicate]) => {
-              const fieldRaw = raw.fields.get(fieldName);
-              if (fieldRaw == undefined) {
-                return ValueOrErrors.Default.return([
-                  fieldName,
-                  { kind: "primitive", value: false },
-                ]);
-              }
-              if (fieldPredicate.kind == "record") {
-                const localBindings = bindings.get("local");
-                const fieldLocal = localBindings.fields.get(fieldName);
-                if (fieldLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: parsing cannot find field ${fieldName} in local ${JSON.stringify(localBindings)}`,
-                  );
+    const bindings = Map()
+        .set("global", context.global)
+        .set("root", root)
+        .set("local", root);
+    const traverse = (bindings, predicate, raw) => {
+        if (predicate.kind == "primitive") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                return ValueOrErrors.Default.return({
+                    kind: "primitive",
+                    value: result,
+                });
+            });
+        }
+        if (predicate.kind == "record") {
+            if (typeof raw != "object" || !("kind" in raw) || raw.kind != "record") {
+                return ValueOrErrors.Default.throwOne(`parsing expected record in raw, got ${JSON.stringify(raw)}`);
+            }
+            return calculateVisibility(predicate.value, bindings).Then((result) => ValueOrErrors.Operations.All(List(predicate.fields
+                .entrySeq()
+                .map(([fieldName, fieldPredicate]) => {
+                const fieldRaw = raw.fields.get(fieldName);
+                if (fieldRaw == undefined) {
+                    return ValueOrErrors.Default.return([
+                        fieldName,
+                        { kind: "primitive", value: false },
+                    ]);
                 }
-                const fieldBindings = bindings.set("local", fieldLocal);
-                return traverse(fieldBindings, fieldPredicate, fieldRaw).Then(
-                  (evaluation) =>
-                    ValueOrErrors.Default.return([fieldName, evaluation]),
-                );
-              }
-              return traverse(bindings, fieldPredicate, fieldRaw).Then(
-                (evaluation) =>
-                  ValueOrErrors.Default.return([fieldName, evaluation]),
-              );
-            }),
-          ),
-        ).Then((evaluations) => {
-          return ValueOrErrors.Default.return({
-            kind: "form",
-            value: result,
-            fields: Map(evaluations.map((_) => [_[0], _[1]])),
-          });
-        }),
-      );
-    }
-    if (predicate.kind == "list") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsTuple(raw)) {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((value, index) => {
-                const elementLocal = raw.values.get(index);
-                if (elementLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`,
-                  );
+                if (fieldPredicate.kind == "record") {
+                    const localBindings = bindings.get("local");
+                    const fieldLocal = localBindings.fields.get(fieldName);
+                    if (fieldLocal == undefined) {
+                        return ValueOrErrors.Default.throwOne(`Error: parsing cannot find field ${fieldName} in local ${JSON.stringify(localBindings)}`);
+                    }
+                    const fieldBindings = bindings.set("local", fieldLocal);
+                    return traverse(fieldBindings, fieldPredicate, fieldRaw).Then((evaluation) => ValueOrErrors.Default.return([fieldName, evaluation]));
                 }
-                const elementBindings = bindings.set("local", elementLocal);
-                return traverse(
-                  elementBindings,
-                  predicate.elementExpression,
-                  value,
-                );
-              }),
-            ),
-          ).Then((elementResults) => {
-            return ValueOrErrors.Default.return({
-              kind: "list",
-              value: result,
-              elementValues: elementResults.toArray(),
+                return traverse(bindings, fieldPredicate, fieldRaw).Then((evaluation) => ValueOrErrors.Default.return([fieldName, evaluation]));
+            }))).Then((evaluations) => {
+                return ValueOrErrors.Default.return({
+                    kind: "form",
+                    value: result,
+                    fields: Map(evaluations.map((_) => [_[0], _[1]])),
+                });
+            }));
+        }
+        if (predicate.kind == "list") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                if (PredicateValue.Operations.IsTuple(raw)) {
+                    return ValueOrErrors.Operations.All(List(raw.values.map((value, index) => {
+                        const elementLocal = raw.values.get(index);
+                        if (elementLocal == undefined) {
+                            return ValueOrErrors.Default.throwOne(`Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`);
+                        }
+                        const elementBindings = bindings.set("local", elementLocal);
+                        return traverse(elementBindings, predicate.elementExpression, value);
+                    }))).Then((elementResults) => {
+                        return ValueOrErrors.Default.return({
+                            kind: "list",
+                            value: result,
+                            elementValues: elementResults.toArray(),
+                        });
+                    });
+                }
+                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple, got ${JSON.stringify(raw)}`);
             });
-          });
         }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "map") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (typeof raw == "object" && "kind" in raw && raw.kind == "tuple") {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((kv) => {
-                if (PredicateValue.Operations.IsTuple(kv)) {
-                  const keyLocal = kv.values.get(0);
-                  const valueLocal = kv.values.get(1);
-                  if (keyLocal == undefined || valueLocal == undefined) {
-                    return ValueOrErrors.Default.throwOne(
-                      `Error: cannot find key or value of ${JSON.stringify(kv)} in local ${JSON.stringify(raw)}`,
-                    );
-                  }
-                  const keyBindings = bindings.set("local", keyLocal);
-                  const valueBindings = bindings.set("local", valueLocal);
-                  return traverse(
-                    keyBindings,
-                    predicate.keyExpression,
-                    keyLocal,
-                  ).Then((keyResult) => {
-                    return traverse(
-                      valueBindings,
-                      predicate.valueExpression,
-                      valueLocal,
-                    ).Then((valueResult) => {
-                      return ValueOrErrors.Default.return({
-                        key: keyResult,
-                        value: valueResult,
-                      });
+        if (predicate.kind == "map") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                if (typeof raw == "object" && "kind" in raw && raw.kind == "tuple") {
+                    return ValueOrErrors.Operations.All(List(raw.values.map((kv) => {
+                        if (PredicateValue.Operations.IsTuple(kv)) {
+                            const keyLocal = kv.values.get(0);
+                            const valueLocal = kv.values.get(1);
+                            if (keyLocal == undefined || valueLocal == undefined) {
+                                return ValueOrErrors.Default.throwOne(`Error: cannot find key or value of ${JSON.stringify(kv)} in local ${JSON.stringify(raw)}`);
+                            }
+                            const keyBindings = bindings.set("local", keyLocal);
+                            const valueBindings = bindings.set("local", valueLocal);
+                            return traverse(keyBindings, predicate.keyExpression, keyLocal).Then((keyResult) => {
+                                return traverse(valueBindings, predicate.valueExpression, valueLocal).Then((valueResult) => {
+                                    return ValueOrErrors.Default.return({
+                                        key: keyResult,
+                                        value: valueResult,
+                                    });
+                                });
+                            });
+                        }
+                        return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple of key and value, got ${JSON.stringify(kv)}`);
+                    }))).Then((keyValues) => {
+                        return ValueOrErrors.Default.return({
+                            kind: "map",
+                            value: result,
+                            elementValues: keyValues.toArray(),
+                        });
                     });
-                  });
                 }
-                return ValueOrErrors.Default.throwOne(
-                  `Error: parsing expected tuple of key and value, got ${JSON.stringify(kv)}`,
-                );
-              }),
-            ),
-          ).Then((keyValues) => {
-            return ValueOrErrors.Default.return({
-              kind: "map",
-              value: result,
-              elementValues: keyValues.toArray(),
+                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple of key value pairs, got ${JSON.stringify(raw)}`);
             });
-          });
         }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple of key value pairs, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "tuple") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsTuple(raw)) {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((value, index) => {
-                const elementLocal = raw.values.get(index);
-                if (elementLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`,
-                  );
+        if (predicate.kind == "tuple") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                if (PredicateValue.Operations.IsTuple(raw)) {
+                    return ValueOrErrors.Operations.All(List(raw.values.map((value, index) => {
+                        const elementLocal = raw.values.get(index);
+                        if (elementLocal == undefined) {
+                            return ValueOrErrors.Default.throwOne(`Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`);
+                        }
+                        const elementBindings = bindings.set("local", elementLocal);
+                        return traverse(elementBindings, predicate.elementExpressions[index], value);
+                    }))).Then((elementResults) => {
+                        return ValueOrErrors.Default.return({
+                            kind: "tuple",
+                            value: result,
+                            elementValues: elementResults.toArray(),
+                        });
+                    });
                 }
-                const elementBindings = bindings.set("local", elementLocal);
-                return traverse(
-                  elementBindings,
-                  predicate.elementExpressions[index],
-                  value,
-                );
-              }),
-            ),
-          ).Then((elementResults) => {
-            return ValueOrErrors.Default.return({
-              kind: "tuple",
-              value: result,
-              elementValues: elementResults.toArray(),
+                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple, got ${JSON.stringify(raw)}`);
             });
-          });
         }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "sum") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsSum(raw)) {
-          const local = raw.value.value;
-          const innerBindings = bindings.set("local", local);
-          return traverse(
-            innerBindings,
-            raw.value.kind === "l"
-              ? predicate.leftExpression
-              : predicate.rightExpression,
-            local,
-          ).Then((innerRes) => {
-            return ValueOrErrors.Default.return(
-              FormFieldPredicateEvaluation.Default.sum(result, innerRes),
-            );
-          });
+        if (predicate.kind == "sum") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                if (PredicateValue.Operations.IsSum(raw)) {
+                    const local = raw.value.value;
+                    const innerBindings = bindings.set("local", local);
+                    return traverse(innerBindings, raw.value.kind === "l"
+                        ? predicate.leftExpression
+                        : predicate.rightExpression, local).Then((innerRes) => {
+                        return ValueOrErrors.Default.return(FormFieldPredicateEvaluation.Default.sum(result, innerRes));
+                    });
+                }
+                return ValueOrErrors.Default.throwOne(`Error: parsing expected sum, got ${JSON.stringify(raw)}`);
+            });
         }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected sum, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "unit") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        return ValueOrErrors.Default.return({
-          kind: "unit",
-          value: result,
-        });
-      });
-    }
-    return ValueOrErrors.Default.throwOne(
-      `Error: parsing unsupported predicate kind ${JSON.stringify(raw)}`,
-    );
-  };
-  const res = traverse(
-    bindings,
-    {
-      kind: "record",
-      value: true,
-      fields: context.visibilityPredicateExpressions,
-    },
-    root,
-  ).Then((visibilities) => {
-    return traverse(
-      bindings,
-      {
+        if (predicate.kind == "unit") {
+            return calculateVisibility(predicate.value, bindings).Then((result) => {
+                return ValueOrErrors.Default.return({
+                    kind: "unit",
+                    value: result,
+                });
+            });
+        }
+        return ValueOrErrors.Default.throwOne(`Error: parsing unsupported predicate kind ${JSON.stringify(raw)}`);
+    };
+    const res = traverse(bindings, {
         kind: "record",
         value: true,
-        fields: context.disabledPredicatedExpressions,
-      },
-      root,
-    ).Then((disabledFields) => {
-      return ValueOrErrors.Default.return({
-        visiblityPredicateEvaluations: visibilities,
-        disabledPredicateEvaluations: disabledFields,
-      });
+        fields: context.visibilityPredicateExpressions,
+    }, root).Then((visibilities) => {
+        return traverse(bindings, {
+            kind: "record",
+            value: true,
+            fields: context.disabledPredicatedExpressions,
+        }, root).Then((disabledFields) => {
+            return ValueOrErrors.Default.return({
+                visiblityPredicateEvaluations: visibilities,
+                disabledPredicateEvaluations: disabledFields,
+            });
+        });
     });
-  });
-  if (res.kind == "errors") {
-    console.error("error evaluating predicates", res);
-  }
-  return res;
+    if (res.kind == "errors") {
+        console.error("error evaluating predicates", res);
+    }
+    return res;
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map