ballerina-core 1.0.229 → 1.0.230

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

@@ -1,1050 +1,1531 @@
 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);
+  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);
     }
-    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`);
-    });
+    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),
-        }),
+  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));
     },
-    Operations: {
-        has: (record, key) => {
-            return record.fields.has(key);
-        },
+    clear: () => {
+      return ValueRecord.Updaters.fields(replaceWith(OrderedMap()));
     },
-    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")),
+  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,
-        }),
-        fromParsed: (from, to, hasMoreValues, data) => ({
-            kind: "table",
-            from,
-            to,
-            data,
-            hasMoreValues,
-        }),
-    },
-    Updaters: Object.assign({}, simpleUpdater()("data")),
+  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,
-    }),
+  Default: (contains) => ({
+    kind: "contains",
+    contains,
+  }),
 };
 export const ValueFilterEqualsTo = {
-    Default: (equalsTo) => ({
-        kind: "=",
-        equalsTo,
-    }),
+  Default: (equalsTo) => ({
+    kind: "=",
+    equalsTo,
+  }),
 };
 export const ValueFilterNotEqualsTo = {
-    Default: (notEqualsTo) => ({
-        kind: "!=",
-        notEqualsTo,
-    }),
+  Default: (notEqualsTo) => ({
+    kind: "!=",
+    notEqualsTo,
+  }),
 };
 export const ValueFilterGreaterThanOrEqualsTo = {
-    Default: (greaterThanOrEqualsTo) => ({
-        kind: ">=",
-        greaterThanOrEqualsTo,
-    }),
+  Default: (greaterThanOrEqualsTo) => ({
+    kind: ">=",
+    greaterThanOrEqualsTo,
+  }),
 };
 export const ValueFilterGreaterThan = {
-    Default: (greaterThan) => ({
-        kind: ">",
-        greaterThan,
-    }),
+  Default: (greaterThan) => ({
+    kind: ">",
+    greaterThan,
+  }),
 };
 export const ValueFilterIsNotNull = {
-    Default: () => ({
-        kind: "!=null",
-    }),
+  Default: () => ({
+    kind: "!=null",
+  }),
 };
 export const ValueFilterIsNull = {
-    Default: () => ({
-        kind: "=null",
-    }),
+  Default: () => ({
+    kind: "=null",
+  }),
 };
 export const ValueFilterSmallerThanOrEqualsTo = {
-    Default: (smallerThanOrEqualsTo) => ({
-        kind: "<=",
-        smallerThanOrEqualsTo,
-    }),
+  Default: (smallerThanOrEqualsTo) => ({
+    kind: "<=",
+    smallerThanOrEqualsTo,
+  }),
 };
 export const ValueFilterSmallerThan = {
-    Default: (smallerThan) => ({
-        kind: "<",
-        smallerThan,
-    }),
+  Default: (smallerThan) => ({
+    kind: "<",
+    smallerThan,
+  }),
 };
 export const ValueFilterStartsWith = {
-    Default: (startsWith) => ({
-        kind: "startsWith",
-        startsWith,
-    }),
+  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,
-            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,
-        }),
+  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,
+      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,
+    }),
+  },
+  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)
+      );
     },
-    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]])))));
+    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 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)
-                    : 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)}.`),
+                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)
+            : 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: {
-        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,
-        }),
+  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"
+      );
     },
-    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)}`));
-        },
+    IsFieldLookup: (e) => {
+      return (
+        typeof e == "object" &&
+        !PredicateValue.Operations.IsDate(e) &&
+        e.kind == "fieldLookup"
+      );
     },
-};
-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,
-                });
-            });
+    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 (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 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 (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);
         }
-        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: 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.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)}`,
+        ),
+      );
+    },
+  },
+};
+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)}`,
+                  );
                 }
-                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,
-                                    });
-                                });
-                            });
-                        }
-                        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(),
-                        });
-                    });
+                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)}`,
+                  );
                 }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple of key value pairs, got ${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(),
             });
+          });
         }
-        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(),
-                        });
+        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,
+                      });
                     });
+                  });
                 }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple, got ${JSON.stringify(raw)}`);
+                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(),
             });
+          });
         }
-        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 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)}`,
+                  );
                 }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected sum, got ${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(),
             });
+          });
         }
-        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 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),
+            );
+          });
         }
-        return ValueOrErrors.Default.throwOne(`Error: parsing unsupported predicate kind ${JSON.stringify(raw)}`);
-    };
-    const res = traverse(bindings, {
+        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,
+      {
         kind: "record",
         value: true,
-        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,
-            });
-        });
+        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