ballerina-core 1.0.211 → 1.0.212

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.211",
+  "version": "1.0.212",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/types/state.ts

@@ -49,7 +49,7 @@ export type SerializedKeyOfType<T> = {
 
 export type ValidatedSerializedKeyOfType<T> = {
   fun: "KeyOf";
-  args: Array<string>;
+  args: [string, Array<string>?];
 };
 
 export type SerializedLookupType = string;
@@ -183,7 +183,7 @@ export const SerializedType = {
     _.fun == "KeyOf" &&
     "args" in _ &&
     Array.isArray(_.args) &&
-    _.args.length == 1 &&
+    (_.args.length == 1 || (_.args.length == 2 && Array.isArray(_.args[1]))) &&
     DispatchisString(_.args[0]),
   isOne: <T>(
     _: SerializedType<T>,
@@ -852,6 +852,11 @@ export const DispatchParsedType = {
                   Map(
                     parsingResult[0].fields
                       .keySeq()
+                      .filter(
+                        (key) =>
+                          rawType.args[1] == undefined ||
+                          !rawType.args[1].includes(key),
+                      )
                       .toArray()
                       .map((key) => [
                         key,

package/src/forms/domains/parser/domains/predicates/state.ts

@@ -556,6 +556,7 @@ export type ExprBinaryOperator = {
   kind: BinaryOperator;
   operands: [Expr, Expr];
 };
+export type ExprPrepend = { kind: "prepend"; operands: [Array<string>, Expr] };
 
 export type Expr =
   | PredicateValue
@@ -565,7 +566,8 @@ export type Expr =
   | ExprBinaryOperator
   | ExprLambda
   | ExprMatchCase
-  | ExprCase;
+  | ExprCase
+  | ExprPrepend;
 
 export const BinaryOperators = ["or", "equals"] as const;
 export const BinaryOperatorsSet = Set(BinaryOperators);
@@ -1314,6 +1316,10 @@ export const PredicateValue = {
 
 export const Expr = {
   Default: {
+    prepend: (prependCases: Array<string>, e: Expr): Expr => ({
+      kind: "prepend",
+      operands: [prependCases, e],
+    }),
     itemLookup: (e: Expr, i: number): Expr => ({
       kind: "itemLookup",
       operands: [e, i],
@@ -1346,6 +1352,13 @@ export const Expr = {
     }),
   },
   Operations: {
+    IsPrepend: (e: Expr): e is ExprPrepend => {
+      return (
+        typeof e == "object" &&
+        !PredicateValue.Operations.IsDate(e) &&
+        e.kind == "prepend"
+      );
+    },
     IsItemLookup: (e: Expr): e is ExprItemLookup => {
       return (
         typeof e == "object" &&
@@ -1487,6 +1500,14 @@ export const Expr = {
               ),
         );
       }
+      if (Expr.Operations.IsPrepend(json)) {
+        const [casesToPrepend, expr]: [Array<string>, 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.`,
       );
@@ -1605,7 +1626,6 @@ export const Expr = {
             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)
@@ -1702,9 +1722,42 @@ export const Expr = {
                                   ),
                                 ),
                               )
-                            : ValueOrErrors.Default.throwOne(
-                                `Error: unsupported expression ${JSON.stringify(e)}`,
-                              );
+                            : Expr.Operations.IsPrepend(e)
+                              ? Expr.Operations.Evaluate(vars)(
+                                  e.operands[1],
+                                ).Then((v) =>
+                                  Expr.Operations.EvaluateAsRecord(vars)(
+                                    v,
+                                  ).Then((v) => {
+                                    const prependEntries: [
+                                      string,
+                                      PredicateValue,
+                                    ][] = e.operands[0].map((c: string) => [
+                                      c,
+                                      PredicateValue.Default.record(
+                                        OrderedMap([["Value", c]]),
+                                      ),
+                                    ]);
+                                    const existingEntries: [
+                                      string,
+                                      PredicateValue,
+                                    ][] = 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(