ts2workflows 0.10.0 → 0.12.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright © 2024 Antti Ajanki, <antti.ajanki@iki.fi>
+Copyright © 2024-2025 Antti Ajanki, <antti.ajanki@iki.fi>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -2,13 +2,20 @@
 
 ts2workflows converts Typescript code to a [GCP Workflows](https://cloud.google.com/workflows/docs/apis) program.
 
+![NPM Version](https://img.shields.io/npm/v/ts2workflows)
+![Node LTS](https://img.shields.io/node/v-lts/ts2workflows)
+
 Only a subset of Typescript features are supported. The [language reference](language_reference.md) describes the supported Typescript features.
 
 See the [samples](samples) directory for code examples.
 
-Project status: It's possible to write Workflows programs, but the transpiler has not been extensively tested. Expect some rough edges!
+## Installation
 
-## Command for transpiling a Typescript file to Workflows syntax
+```sh
+npm install ts2workflows
+```
+
+## Usage
 
 Converting Typescript code in a file samples/sample1.ts into GCP Workflows YAML syntax on stdout:
 
@@ -22,13 +29,25 @@ Compile multiple files and write result to an output directory `workflowsfiles`.
 npx ts2workflows --project samples/tsconfig.json --outdir workflowsfiles samples/*.ts
 ```
 
+The `--link` argument generates YAML output that includes all necessary subworkflows (i.e. imported Typescript functions) in a single file. It will generate one output file for each input file.
+
+```sh
+npx ts2workflows --link --project samples/tsconfig.json --outdir workflowsfiles samples/sample*.ts
+```
+
 When developing ts2workflows, you can run the transpiler directly from the source directory:
 
 ```sh
 npx tsx src/cli.ts samples/sample1.ts
 ```
 
-## Type checking
+### Command arguments
+
+- `--project`: Path to TSConfig for the Typescript sources files
+- `--link`: Emit a self-contained YAML. That is, the output includes code from the main input file and all subworkflows imported from the main file. Without this, emits only subworkflows in the input file. Requires --project.
+- `--[no-]generated-file-comment`: Start the output with a comment mentioning that the file has been generated by ts2workflows.
+
+## Type checking workflow sources
 
 One benefit of writing the workflow programs in Typescript is that the sources can be type checked.
 
@@ -48,20 +67,28 @@ import { http, retry_policy } from 'ts2workflows/types/workflowslib'
 
 Type checking step is completely separate from the transpiling. The ts2workflows command ignores type annotations.
 
-## Build
+## Development
 
-```
+### Build
+
+```sh
 npm install
 npm run build
 ```
 
-## Run unit tests
+### Run unit tests
 
-```
+```sh
 npm run test
 ```
 
-## Architecture
+Run tests and print the test coverage:
+
+```sh
+npm run test-coverage
+```
+
+### Architecture
 
 A transpilation using ts2workflows consists of five phases:
 
@@ -75,7 +102,7 @@ The main function implementing these phases is `transpile()` in [src/transpiler/
 
 The transpiler parses a Typescript source file using [@typescript-eslint/typescript-estree](https://www.npmjs.com/package/@typescript-eslint/typescript-estree) module by the [typescript-eslint](https://typescript-eslint.io/) project. The result of the parsing is an [ESTree](https://github.com/estree/estree/blob/master/README.md)-compatible abstract syntax tree (AST) of the source code. [typescript-eslint playgroud](https://typescript-eslint.io/play/) is an useful tool for exploring the Typescript parsing.
 
-Next, ts2workflows converts the AST to a custom intermediate representation (IR). The IR format brings the representation of the program closer the GCP Workflows language than Typescript code. The types for IR are defined in the [src/ast](src/ast) directory. Particularly, see [src/ast/steps.ts](src/ast/steps.ts) for Workflow step types and [src/ast/expressions.ts](src/ast/expressions.ts) for expression types.
+Next, ts2workflows converts the AST to a custom intermediate representation (IR). The IR format brings the representation of the program closer the GCP Workflows language than Typescript code. The types for IR are defined in the [src/ast](src/ast) directory. Particularly, see [src/ast/statements.ts](src/ast/statements.ts) for statement types and [src/ast/expressions.ts](src/ast/expressions.ts) for expression types.
 
 The transpiler applies a few transformations to the IR to make it a valid and optimized Workflows program. These transformations, for example, merge consecutive assignments into a single assign step and ensure that blocking function are invoked by call steps (as required by Workflows). The transformations are implemented in [src/transpiler/transformations.ts](src/transpiler/transformations.ts).
 

package/dist/ast/expressions.d.ts

@@ -1,66 +1,62 @@
 export type VariableName = string;
 export type BinaryOperator = '+' | '-' | '*' | '/' | '//' | '%' | '==' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'and' | 'or';
 export type UnaryOperator = '-' | '+' | 'not';
-export type Primitive = null | string | number | boolean | (Primitive | Expression)[] | {
-    [key: string]: Primitive | Expression;
-};
 export type LiteralValueOrLiteralExpression = null | string | number | boolean | LiteralValueOrLiteralExpression[] | {
     [key: string]: LiteralValueOrLiteralExpression;
 };
-export type Expression = PrimitiveExpression | BinaryExpression | VariableReferenceExpression | FunctionInvocationExpression | MemberExpression | UnaryExpression;
-export declare class PrimitiveExpression {
-    readonly expressionType = "primitive";
-    readonly value: Primitive;
-    constructor(value: Primitive);
-    toString(): string;
+export type Expression = NullExpression | StringExpression | NumberExpression | BooleanExpression | ListExpression | MapExpression | BinaryExpression | VariableReferenceExpression | FunctionInvocationExpression | MemberExpression | UnaryExpression;
+interface ExpressionLiteral<V, Tag> {
+    readonly tag: Tag;
+    readonly value: V;
 }
-export declare const nullEx: PrimitiveExpression;
-export declare const trueEx: PrimitiveExpression;
-export declare const falseEx: PrimitiveExpression;
-export declare class BinaryExpression {
-    readonly expressionType = "binary";
+export type NullExpression = ExpressionLiteral<null, 'null'>;
+export type StringExpression = ExpressionLiteral<string, 'string'>;
+export type NumberExpression = ExpressionLiteral<number, 'number'>;
+export type BooleanExpression = ExpressionLiteral<boolean, 'boolean'>;
+export type ListExpression = ExpressionLiteral<Expression[], 'list'>;
+export type MapExpression = ExpressionLiteral<Record<string, Expression>, 'map'>;
+export declare const nullEx: NullExpression;
+export declare function stringEx(value: string): StringExpression;
+export declare function numberEx(value: number): NumberExpression;
+export declare function booleanEx(value: boolean): BooleanExpression;
+export declare const trueEx: BooleanExpression;
+export declare const falseEx: BooleanExpression;
+export declare function listEx(value: Expression[]): ListExpression;
+export declare function mapEx(value: Record<string, Expression>): MapExpression;
+export interface BinaryExpression {
+    readonly tag: 'binary';
     readonly binaryOperator: BinaryOperator;
     readonly left: Expression;
     readonly right: Expression;
-    constructor(left: Expression, binaryOperator: BinaryOperator, right: Expression);
-    toString(): string;
 }
-export declare class VariableReferenceExpression {
-    readonly expressionType = "variableReference";
+export declare function binaryEx(left: Expression, binaryOperator: BinaryOperator, right: Expression): BinaryExpression;
+export interface VariableReferenceExpression {
+    readonly tag: 'variableReference';
     readonly variableName: VariableName;
-    constructor(variableName: VariableName);
-    toString(): string;
 }
-export declare class FunctionInvocationExpression {
-    readonly expressionType = "functionInvocation";
+export declare function variableReferenceEx(variableName: VariableName): VariableReferenceExpression;
+export interface FunctionInvocationExpression {
+    readonly tag: 'functionInvocation';
     readonly functionName: string;
     readonly arguments: Expression[];
-    constructor(functionName: string, argumentExpressions: Expression[]);
-    toString(): string;
 }
-export declare class MemberExpression {
-    readonly expressionType = "member";
+export declare function functionInvocationEx(functionName: string, argumentExpressions: Expression[]): FunctionInvocationExpression;
+export interface MemberExpression {
+    readonly tag: 'member';
     readonly object: Expression;
     readonly property: Expression;
     readonly computed: boolean;
-    constructor(object: Expression, property: Expression, computed: boolean);
-    toString(): string;
 }
-export declare class UnaryExpression {
-    readonly expressionType = "unary";
+export declare function memberEx(object: Expression, property: Expression, computed: boolean): MemberExpression;
+export interface UnaryExpression {
+    readonly tag: 'unary';
     readonly operator: UnaryOperator;
     readonly value: Expression;
-    constructor(operator: UnaryOperator, value: Expression);
-    toString(): string;
 }
-export declare function isExpression(val: Primitive | Expression): val is Expression;
-export declare function asExpression(x: Primitive | Expression): Expression;
-export declare function safeAsExpression(x: Primitive | Expression | undefined): Expression | undefined;
+export declare function unaryEx(operator: UnaryOperator, value: Expression): UnaryExpression;
+export declare function expressionToString(ex: Expression): string;
 export declare function expressionToLiteralValueOrLiteralExpression(ex: Expression): LiteralValueOrLiteralExpression;
-export declare function isLiteral(ex: Expression): boolean;
-export declare function isFullyQualifiedName(ex: Expression): boolean;
-/**
- * Returns true if ex is pure expression (can't have side-effects)
- */
-export declare function isPure(ex: Expression): boolean;
+export declare function isQualifiedName(ex: Expression): boolean;
+export declare function isPrimitive(ex: Expression): ex is StringExpression | NumberExpression | BooleanExpression | NullExpression;
+export {};
 //# sourceMappingURL=expressions.d.ts.map

package/dist/ast/expressions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/ast/expressions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/ast/expressions.ts"],"names":[],"mappings":"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"}

package/dist/ast/expressions.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { isRecord } from '../utils.js';
 // Operator precendence for unary and binary operators in the Workflows language.
 // Note that these differ somewhat from Javascript.
 // https://cloud.google.com/workflows/docs/reference/syntax/datatypes
@@ -24,171 +23,130 @@ const operatorPrecedenceValue = new Map([
     ['and', 2],
     ['or', 1],
 ]);
-// A primitive (string, number, list, etc) value
-export class PrimitiveExpression {
-    expressionType = 'primitive';
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    // Return the string representation of this expression.
-    // Not enclosed in ${}.
-    toString() {
-        const val = this.value;
-        if (Array.isArray(val)) {
-            const elements = val.map((v) => {
-                return isExpression(v) ? v.toString() : primitiveToString(v);
-            });
-            return `[${elements.join(', ')}]`;
-        }
-        else if (isRecord(val)) {
-            const elements = Object.entries(val).map(([k, v]) => {
-                return `"${k}": ${isExpression(v) ? v.toString() : primitiveToString(v)}`;
-            });
-            return `{${elements.join(', ')}}`;
-        }
-        else {
-            return `${JSON.stringify(val)}`;
-        }
-    }
-}
-export const nullEx = new PrimitiveExpression(null);
-export const trueEx = new PrimitiveExpression(true);
-export const falseEx = new PrimitiveExpression(false);
-// expr OPERATOR expr
-export class BinaryExpression {
-    expressionType = 'binary';
-    binaryOperator;
-    left;
-    right;
-    constructor(left, binaryOperator, right) {
-        this.binaryOperator = binaryOperator;
-        this.left = left;
-        this.right = right;
-    }
-    toString() {
-        let leftString = this.left.toString();
-        let rightString = this.right.toString();
-        if (this.left.expressionType === 'binary') {
-            const leftOpValue = operatorPrecedenceValue.get(this.left.binaryOperator) ?? 0;
-            const thisOpValue = operatorPrecedenceValue.get(this.binaryOperator) ?? 0;
-            if (leftOpValue < thisOpValue) {
-                leftString = `(${leftString})`;
+export const nullEx = { tag: 'null', value: null };
+export function stringEx(value) {
+    return { tag: 'string', value };
+}
+export function numberEx(value) {
+    return { tag: 'number', value };
+}
+export function booleanEx(value) {
+    return { tag: 'boolean', value };
+}
+export const trueEx = booleanEx(true);
+export const falseEx = booleanEx(false);
+export function listEx(value) {
+    return { tag: 'list', value };
+}
+export function mapEx(value) {
+    return { tag: 'map', value };
+}
+export function binaryEx(left, binaryOperator, right) {
+    return {
+        tag: 'binary',
+        binaryOperator,
+        left,
+        right,
+    };
+}
+export function variableReferenceEx(variableName) {
+    return { tag: 'variableReference', variableName };
+}
+export function functionInvocationEx(functionName, argumentExpressions) {
+    return {
+        tag: 'functionInvocation',
+        functionName,
+        arguments: argumentExpressions,
+    };
+}
+export function memberEx(object, property, computed) {
+    return { tag: 'member', object, property, computed };
+}
+export function unaryEx(operator, value) {
+    return { tag: 'unary', operator, value };
+}
+// Returns a string representation of ex, not enclosed in ${}
+export function expressionToString(ex) {
+    switch (ex.tag) {
+        case 'string':
+            return JSON.stringify(ex.value);
+        case 'number':
+            return ex.value.toString();
+        case 'boolean':
+            return ex.value ? 'true' : 'false';
+        case 'null':
+            return 'null';
+        case 'list':
+            return '[' + ex.value.map(expressionToString).join(', ') + ']';
+        case 'map':
+            return ('{' +
+                Object.entries(ex.value)
+                    .map(([key, val]) => JSON.stringify(key) + ': ' + expressionToString(val))
+                    .join(', ') +
+                '}');
+        case 'binary':
+            return binaryExpressionToString(ex);
+        case 'variableReference':
+            return ex.variableName;
+        case 'functionInvocation':
+            return `${ex.functionName}(${ex.arguments.map(expressionToString).join(', ')})`;
+        case 'member':
+            if (ex.computed) {
+                return `${expressionToString(ex.object)}[${expressionToString(ex.property)}]`;
             }
-        }
-        if (this.right.expressionType === 'binary') {
-            const rightOpValue = operatorPrecedenceValue.get(this.right.binaryOperator) ?? 0;
-            const thisOpValue = operatorPrecedenceValue.get(this.binaryOperator) ?? 0;
-            if (rightOpValue < thisOpValue) {
-                rightString = `(${rightString})`;
+            else {
+                return `${expressionToString(ex.object)}.${expressionToString(ex.property)}`;
             }
-        }
-        return `${leftString} ${this.binaryOperator} ${rightString}`;
-    }
-}
-// Variable name: a plain identifier (y, year) or a list
-// element accessor (names[3])
-export class VariableReferenceExpression {
-    expressionType = 'variableReference';
-    variableName;
-    constructor(variableName) {
-        this.variableName = variableName;
-    }
-    toString() {
-        return this.variableName;
-    }
-}
-// Function invocation with anonymous parameters: sys.get_env("GOOGLE_CLOUD_PROJECT_ID")
-export class FunctionInvocationExpression {
-    expressionType = 'functionInvocation';
-    functionName;
-    arguments;
-    constructor(functionName, argumentExpressions) {
-        this.functionName = functionName;
-        this.arguments = argumentExpressions;
-    }
-    toString() {
-        const argumentStrings = this.arguments.map((x) => x.toString());
-        return `${this.functionName}(${argumentStrings.join(', ')})`;
+        case 'unary':
+            return unaryExpressionToString(ex);
     }
 }
-// object.property or object[property]
-export class MemberExpression {
-    expressionType = 'member';
-    object;
-    property;
-    computed;
-    constructor(object, property, computed) {
-        this.object = object;
-        this.property = property;
-        this.computed = computed;
-    }
-    toString() {
-        if (this.computed) {
-            return `${this.object.toString()}[${this.property.toString()}]`;
-        }
-        else {
-            return `${this.object.toString()}.${this.property.toString()}`;
+function binaryExpressionToString(ex) {
+    let leftString = expressionToString(ex.left);
+    let rightString = expressionToString(ex.right);
+    if (ex.left.tag === 'binary') {
+        const leftOpValue = operatorPrecedenceValue.get(ex.left.binaryOperator) ?? 0;
+        const thisOpValue = operatorPrecedenceValue.get(ex.binaryOperator) ?? 0;
+        if (leftOpValue < thisOpValue) {
+            leftString = `(${leftString})`;
         }
     }
-}
-export class UnaryExpression {
-    expressionType = 'unary';
-    operator;
-    value;
-    constructor(operator, value) {
-        this.operator = operator;
-        this.value = value;
-    }
-    toString() {
-        const separator = this.operator === 'not' ? ' ' : '';
-        let valueString = this.value.toString();
-        if (this.value.expressionType === 'binary') {
-            valueString = `(${valueString})`;
+    if (ex.right.tag === 'binary') {
+        const rightOpValue = operatorPrecedenceValue.get(ex.right.binaryOperator) ?? 0;
+        const thisOpValue = operatorPrecedenceValue.get(ex.binaryOperator) ?? 0;
+        if (rightOpValue < thisOpValue) {
+            rightString = `(${rightString})`;
         }
-        return `${this.operator}${separator}${valueString}`;
     }
+    return `${leftString} ${ex.binaryOperator} ${rightString}`;
 }
-// Convert an Expression or Primitive to a string representation.
-// Does not add ${}.
-const expressionOrPrimitiveToString = R.ifElse(isExpression, (x) => x.toString(), primitiveToString);
-// Convert a Primitive to a string representation.
-// Does not add ${}.
-function primitiveToString(val) {
-    const valuesToString = R.map(expressionOrPrimitiveToString);
-    if (Array.isArray(val)) {
-        return `[${valuesToString(val).join(', ')}]`;
+function unaryExpressionToString(ex) {
+    const separator = ex.operator === 'not' ? ' ' : '';
+    let valueString = expressionToString(ex.value);
+    if (ex.value.tag === 'binary') {
+        valueString = `(${valueString})`;
     }
-    else if (val !== null && typeof val === 'object') {
-        const elements = Object.values(valuesToString(val)).map(([k, v]) => `"${k}":${v}`);
-        return `{${elements.join(',')}}`;
-    }
-    else {
-        return JSON.stringify(val);
-    }
-}
-export function isExpression(val) {
-    return val instanceof Object && 'expressionType' in val && !isRecord(val);
-}
-export function asExpression(x) {
-    return isExpression(x) ? x : new PrimitiveExpression(x);
-}
-export function safeAsExpression(x) {
-    return x === undefined ? undefined : asExpression(x);
+    return `${ex.operator}${separator}${valueString}`;
 }
 // Returns a literal for simple terms and a literal expression enclosed in ${} for complex terms.
 export function expressionToLiteralValueOrLiteralExpression(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return primitiveExpressionToLiteralValueOrLiteralExpression(ex);
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
+            return ex.value;
+        case 'list':
+            return R.map(expressionToLiteralValueOrLiteralExpression, ex.value);
+        case 'map':
+            return R.map(expressionToLiteralValueOrLiteralExpression, ex.value);
         case 'binary':
         case 'variableReference':
         case 'functionInvocation':
         case 'member':
-            return `\${${ex.toString()}}`;
+            return `\${${expressionToString(ex)}}`;
         case 'unary':
-            if (ex.value.expressionType === 'primitive' &&
-                typeof ex.value.value === 'number') {
+            if (ex.value.tag === 'number') {
                 if (ex.operator === '+') {
                     return ex.value.value;
                 }
@@ -196,98 +154,22 @@ export function expressionToLiteralValueOrLiteralExpression(ex) {
                     return -ex.value.value;
                 }
                 else {
-                    return `\${${ex.toString()}}`;
+                    return `\${${expressionToString(ex)}}`;
                 }
             }
             else {
-                return `\${${ex.toString()}}`;
-            }
-    }
-}
-function primitiveExpressionToLiteralValueOrLiteralExpression(ex) {
-    if (typeof ex.value === 'number' ||
-        typeof ex.value === 'string' ||
-        typeof ex.value === 'boolean' ||
-        ex.value === null) {
-        return ex.value;
-    }
-    else if (Array.isArray(ex.value)) {
-        return ex.value.map((x) => {
-            if (isExpression(x)) {
-                return expressionToLiteralValueOrLiteralExpression(x);
-            }
-            else if (Array.isArray(x) || isRecord(x)) {
-                return primitiveExpressionToLiteralValueOrLiteralExpression(new PrimitiveExpression(x));
-            }
-            else if (x === null ||
-                typeof x === 'string' ||
-                typeof x === 'number' ||
-                typeof x === 'boolean') {
-                return x;
-            }
-            else {
-                return `\${${primitiveToString(x)}}`;
+                return `\${${expressionToString(ex)}}`;
             }
-        });
-    }
-    else if (isRecord(ex.value)) {
-        const mapRecord = R.map((v) => {
-            if (isExpression(v)) {
-                return expressionToLiteralValueOrLiteralExpression(v);
-            }
-            else if (Array.isArray(v) || isRecord(v)) {
-                return primitiveExpressionToLiteralValueOrLiteralExpression(new PrimitiveExpression(v));
-            }
-            else if (v === null ||
-                typeof v === 'string' ||
-                typeof v === 'number' ||
-                typeof v === 'boolean') {
-                return v;
-            }
-            else {
-                return `\${${primitiveToString(v)}}`;
-            }
-        });
-        return mapRecord(ex.value);
-    }
-    else {
-        return `\${${ex.toString()}}`;
     }
 }
-// Returns true if expression is a literal value.
-// Examples of literals: number, string, array of numbers or strings, etc.
-// Examples of non-literals: array that contains complex expressions.
-export function isLiteral(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return primitiveIsLiteral(ex.value);
-        case 'unary':
-            return isLiteral(ex.value);
-        case 'binary':
-        case 'variableReference':
-        case 'functionInvocation':
-        case 'member':
-            return false;
-    }
-}
-const expressionOrPrimitiveIsLiteral = R.ifElse(isExpression, isLiteral, primitiveIsLiteral);
-function primitiveIsLiteral(value) {
-    if (Array.isArray(value)) {
-        return value.every(expressionOrPrimitiveIsLiteral);
-    }
-    else if (isRecord(value)) {
-        return Object.values(value).every(expressionOrPrimitiveIsLiteral);
-    }
-    else {
-        return (typeof value === 'string' ||
-            typeof value === 'number' ||
-            typeof value === 'boolean' ||
-            value === null);
-    }
-}
-export function isFullyQualifiedName(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
+export function isQualifiedName(ex) {
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
+        case 'list':
+        case 'map':
         case 'binary':
         case 'functionInvocation':
         case 'unary':
@@ -295,27 +177,14 @@ export function isFullyQualifiedName(ex) {
         case 'variableReference':
             return true;
         case 'member':
-            return (isFullyQualifiedName(ex.object) &&
-                (isFullyQualifiedName(ex.property) ||
-                    (ex.computed && ex.property.expressionType === 'primitive')));
+            return (isQualifiedName(ex.object) &&
+                (isQualifiedName(ex.property) ||
+                    (ex.computed && isPrimitive(ex.property))));
     }
 }
-/**
- * Returns true if ex is pure expression (can't have side-effects)
- */
-export function isPure(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return true;
-        case 'binary':
-            return isPure(ex.left) && isPure(ex.right);
-        case 'functionInvocation':
-            return false;
-        case 'variableReference':
-            return true;
-        case 'member':
-            return isPure(ex.object) && isPure(ex.property);
-        case 'unary':
-            return isPure(ex.value);
-    }
+export function isPrimitive(ex) {
+    return (ex.tag === 'string' ||
+        ex.tag === 'number' ||
+        ex.tag === 'boolean' ||
+        ex.tag === 'null');
 }