ts2workflows 0.10.0 → 0.12.0

package/dist/transpiler/transformations.js

@@ -1,342 +1,331 @@
 import * as R from 'ramda';
-import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, } from '../ast/steps.js';
 import { InternalTranspilingError } from '../errors.js';
-import { isRecord } from '../utils.js';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, asExpression, isExpression, isLiteral, } from '../ast/expressions.js';
+import { binaryEx, functionInvocationEx, listEx, mapEx, memberEx, stringEx, unaryEx, variableReferenceEx, } from '../ast/expressions.js';
+import { applyNested, AssignStatement, FunctionInvocationStatement, IfStatement, LabelledStatement, } from '../ast/statements.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 /**
  * Performs various transformations on the AST.
  */
-const transformPipe = R.pipe(mapLiteralsAsAssignSteps, mergeAssignSteps, flattenPlainNextConditions, intrinsicFunctionImplementation, blockingCallsAsCallSteps);
-export function transformAST(steps) {
-    return transformPipe(steps.map((x) => x.applyNestedSteps(transformAST)));
+export function transformAST(statements) {
+    const tempGen = createTempVariableGenerator();
+    const transform = R.pipe(R.chain(mapLiteralsAsAssigns(tempGen)), mergeAssigns, R.chain(intrinsicFunctionImplementation), R.chain(blockingCallsAsFunctionCalls(tempGen)));
+    return transform(statements.map((s) => applyNested(transformAST, s)));
 }
 /**
- * Merge consecutive assign steps into one assign step
+ * Merge consecutive assign statements into one assign statement
  *
- * An assign step can contain up to 50 assignments.
+ * An assign is allowed to contain up to 50 assignments.
  */
-function mergeAssignSteps(steps) {
-    return steps.reduce((acc, current) => {
+function mergeAssigns(statements) {
+    return statements.reduce((acc, current) => {
         const prev = acc.length > 0 ? acc[acc.length - 1] : null;
-        if (current.tag === 'assign' &&
-            prev?.tag === 'assign' &&
-            prev.assignments.length < 50 &&
-            !prev.next) {
-            const merged = new AssignStepAST(prev.assignments.concat(current.assignments), current.next, prev.label ?? current.label);
-            acc.pop();
-            acc.push(merged);
+        let prevAssignments = undefined;
+        let label = undefined;
+        if (prev?.tag === 'assign') {
+            prevAssignments = prev.assignments;
         }
-        else {
-            acc.push(current);
+        else if (prev?.tag === 'label' &&
+            prev.statements.every((x) => x.tag === 'assign')) {
+            prevAssignments = prev.statements.flatMap((x) => x.assignments);
+            label = prev.label;
         }
-        return acc;
-    }, []);
-}
-/**
- * Merge a next step to the previous step.
- *
- * For example, transforms this:
- *
- * switch:
- *   - condition: ${x > 0}
- *     steps:
- *       - next1:
- *           steps:
- *             next: target1
- *
- * into this:
- *
- * switch:
- *   - condition: ${x > 0}
- *     next: target1
- */
-export function flattenPlainNextConditions(steps) {
-    return steps.reduce((acc, step) => {
-        if (acc.length > 0 && step.tag === 'next') {
-            // Merge a "next" to the previous "assign" step
-            const prev = acc[acc.length - 1];
-            if (prev.tag === 'assign' && !prev.next) {
-                acc.pop();
-                acc.push(prev.withNext(step.target));
-            }
-            else {
-                acc.push(step);
-            }
-        }
-        else if (step.tag === 'switch') {
-            // If the condition steps consists of a single "next", merge it with the condition
-            acc.push(flattenNextToCondition(step));
+        let currentAssignments = undefined;
+        if (current.tag === 'assign') {
+            currentAssignments = current.assignments;
         }
-        else {
-            acc.push(step);
-        }
-        return acc;
-    }, []);
-}
-function flattenNextToCondition(step) {
-    const transformedBranches = step.branches.map((cond) => {
-        if (!cond.next && cond.steps.length === 1 && cond.steps[0].tag === 'next') {
-            const nextStep = cond.steps[0];
-            return {
-                condition: cond.condition,
-                steps: [],
-                next: nextStep.target,
-            };
-        }
-        else {
-            return cond;
-        }
-    });
-    return new SwitchStepAST(transformedBranches);
-}
-/**
- * Search for blocking calls in expressions and replace them with call step + variable.
- *
- * The Workflows runtime requires that blocking calls must be executed by call steps.
- *
- * For example, transforms this:
- *
- * - return1:
- *     return: ${http.get("https://example.com")}
- *
- * into this:
- *
- * - call_http_get_1:
- *     call: http.get
- *     args:
- *       url: https://example.com
- *     result: __temp0
- * - return1:
- *     return: ${__temp0}
- */
-function blockingCallsAsCallSteps(steps) {
-    const transform = transformStepExpressions(replaceBlockingCalls);
-    return R.chain(transform, steps);
-}
-function createTempVariableGenerator() {
-    let i = 0;
-    return () => `__temp${i++}`;
-}
-function replaceBlockingCalls(expression) {
-    function replaceBlockingFunctionInvocations(ex) {
-        if (ex.expressionType !== 'functionInvocation') {
-            return ex;
+        else if (current.tag === 'label' &&
+            current.statements.every((x) => x.tag === 'assign')) {
+            currentAssignments = current.statements.flatMap((x) => x.assignments);
+            label ??= current.label;
         }
-        const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
-        if (blockingCallArgumentNames) {
-            if (ex.arguments.length > blockingCallArgumentNames.length) {
-                throw new InternalTranspilingError('FunctionInvocationTerm has more arguments than metadata allows!');
+        if (prevAssignments && currentAssignments) {
+            let merged = new AssignStatement(prevAssignments.concat(currentAssignments));
+            if (label) {
+                merged = new LabelledStatement(label, [merged]);
             }
-            const nameAndValue = R.zip(blockingCallArgumentNames, ex.arguments);
-            const callArgs = R.fromPairs(nameAndValue);
-            const tempCallResultVariable = generateName();
-            callSteps.push(new CallStepAST(ex.functionName, callArgs, tempCallResultVariable));
-            // replace function invocation with a reference to the temporary variable
-            return new VariableReferenceExpression(tempCallResultVariable);
+            acc.pop();
+            acc.push(merged);
         }
         else {
-            return ex;
+            acc.push(current);
         }
-    }
-    const generateName = createTempVariableGenerator();
-    const callSteps = [];
-    return [
-        callSteps,
-        transformExpression(replaceBlockingFunctionInvocations, expression),
-    ];
+        return acc;
+    }, []);
 }
 /**
- * Transform expressions in a step by applying transform.
+ * Transform expressions in a statement by applying transform.
  *
- * Returns an array of steps. The array includes the transformed step and possibly
- * additional steps constructed during the transformation. For example, a
- * transformation might extract blocking call expressions into call steps.
+ * Returns an array of statements. The array includes the transformed statement
+ * and possibly additional statements constructed during the transformation.
+ * For example, a transformation might extract blocking call expressions into
+ * function call.
  */
-const transformStepExpressions = R.curry(function (transform, step) {
-    switch (step.tag) {
+const expandExpressionToStatements = R.curry(function (transform, statement) {
+    switch (statement.tag) {
         case 'assign':
-            return transformExpressionsAssign(transform, step);
-        case 'call':
-            return transformExpressionsCall(transform, step);
+            return expandAssign(transform, statement);
+        case 'function-invocation':
+            return expandFunctionInvocation(transform, statement);
         case 'for':
-            return transformExpressionsFor(transform, step);
+            return expandFor(transform, statement);
+        case 'for-range':
+            return expandForRange(transform, statement);
+        case 'if':
+            return expandIf(transform, statement);
         case 'raise':
-            return transformExpressionsRaise(transform, step);
+            return expandRaise(transform, statement);
         case 'return':
-            return transformExpressionsReturn(transform, step);
+            return expanrdReturn(transform, statement);
         case 'switch':
-            return transformExpressionsSwitch(transform, step);
-        case 'forrange':
-        case 'next':
+            return expandSwitch(transform, statement);
+        case 'while':
+        case 'do-while':
+            return expandWhile(transform, statement);
+        case 'break':
+        case 'continue':
+        case 'label':
         case 'parallel':
-        case 'steps':
+        case 'parallel-for':
         case 'try':
-        case 'jumptarget':
-            return [step];
+            return [statement];
     }
 });
-function transformExpressionsAssign(transform, step) {
-    if (step.assignments) {
-        const newSteps = [];
-        const newAssignments = step.assignments.map(({ name, value }) => {
-            const [steps2, transformedKey] = transform(name);
-            const [steps3, transformedValue] = transform(value);
-            newSteps.push(...steps2);
-            newSteps.push(...steps3);
-            if (transformedKey.expressionType !== 'variableReference' &&
-                transformedKey.expressionType !== 'member') {
-                throw new InternalTranspilingError('Unexpected key type when transforming assign step');
-            }
-            return { name: transformedKey, value: transformedValue };
-        });
-        newSteps.push(new AssignStepAST(newAssignments, step.next, step.label));
-        return newSteps;
-    }
-    else {
-        return [step];
-    }
+function expandAssign(transform, statement) {
+    const newStatements = [];
+    const newAssignments = statement.assignments.map(({ name, value }) => {
+        const [st2, transformedKey] = transform(name);
+        const [st3, transformedValue] = transform(value);
+        newStatements.push(...st2);
+        newStatements.push(...st3);
+        if (transformedKey.tag !== 'variableReference' &&
+            transformedKey.tag !== 'member') {
+            throw new InternalTranspilingError('Unexpected key type when transforming an assignment');
+        }
+        return { name: transformedKey, value: transformedValue };
+    });
+    newStatements.push({ ...statement, assignments: newAssignments });
+    return newStatements;
 }
-function transformExpressionsCall(transform, step) {
-    if (step.args) {
-        const newSteps = [];
+function expandFunctionInvocation(transform, statement) {
+    if (statement.args) {
+        const newStatements = [];
         const newArgs = R.map((ex) => {
-            const [steps2, ex2] = transform(ex);
-            newSteps.push(...steps2);
+            const [st2, ex2] = transform(ex);
+            newStatements.push(...st2);
             return ex2;
-        }, step.args);
-        newSteps.push(new CallStepAST(step.call, newArgs, step.result, step.label));
-        return newSteps;
+        }, statement.args);
+        newStatements.push({ ...statement, args: newArgs });
+        return newStatements;
     }
     else {
-        return [step];
+        return [statement];
     }
 }
-function transformExpressionsFor(transform, step) {
-    if (step.listExpression) {
-        const [newSteps, newListExpression] = transform(step.listExpression);
-        newSteps.push(new ForStepAST(step.steps, step.loopVariableName, newListExpression, step.indexVariableName, step.label));
-        return newSteps;
+function expandFor(transform, statement) {
+    const [res, newListExpression] = transform(statement.listExpression);
+    res.push({ ...statement, listExpression: newListExpression });
+    return res;
+}
+function expandForRange(transform, statement) {
+    const res = [];
+    let newRangeStart;
+    let newRangeEnd;
+    if (typeof statement.rangeStart === 'number') {
+        newRangeStart = statement.rangeStart;
     }
     else {
-        return [step];
+        const [st1, ex1] = transform(statement.rangeStart);
+        res.push(...st1);
+        newRangeStart = ex1;
     }
-}
-function transformExpressionsRaise(transform, step) {
-    if (step.value) {
-        const [newSteps, newEx] = transform(step.value);
-        newSteps.push(new RaiseStepAST(newEx, step.label));
-        return newSteps;
+    if (typeof statement.rangeEnd === 'number') {
+        newRangeEnd = statement.rangeEnd;
     }
     else {
-        return [step];
+        const [st2, ex2] = transform(statement.rangeEnd);
+        res.push(...st2);
+        newRangeEnd = ex2;
     }
+    res.push({ ...statement, rangeStart: newRangeStart, rangeEnd: newRangeEnd });
+    return res;
+}
+function expandIf(transform, statement) {
+    const res = [];
+    const newBranches = statement.branches.map((branch) => {
+        const [st, ex] = transform(branch.condition);
+        res.push(...st);
+        return {
+            ...branch,
+            condition: ex,
+        };
+    });
+    res.push(new IfStatement(newBranches));
+    return res;
 }
-function transformExpressionsReturn(transform, step) {
-    if (step.value) {
-        const [newSteps, newEx] = transform(step.value);
-        newSteps.push(new ReturnStepAST(newEx, step.label));
-        return newSteps;
+function expandRaise(transform, statement) {
+    const [res, newEx] = transform(statement.value);
+    res.push({ ...statement, value: newEx });
+    return res;
+}
+function expanrdReturn(transform, statement) {
+    if (statement.value) {
+        const [newStatements, newEx] = transform(statement.value);
+        newStatements.push({ ...statement, value: newEx });
+        return newStatements;
     }
     else {
-        return [step];
+        return [statement];
     }
 }
-function transformExpressionsSwitch(transform, step) {
-    const newSteps = [];
-    const newBranches = step.branches.map((cond) => {
-        const [steps2, ex2] = transform(cond.condition);
-        newSteps.push(...steps2);
+function expandSwitch(transform, statement) {
+    const res = [];
+    const newBranches = statement.branches.map((branch) => {
+        const [st2, ex2] = transform(branch.condition);
+        res.push(...st2);
         return {
             condition: ex2,
-            steps: cond.steps,
-            next: cond.next,
+            body: branch.body,
         };
     });
-    newSteps.push(new SwitchStepAST(newBranches, step.label));
-    return newSteps;
+    res.push({ ...statement, branches: newBranches });
+    return res;
+}
+function expandWhile(transform, statement) {
+    const [res, newCond] = transform(statement.condition);
+    res.push({ ...statement, condition: newCond });
+    return res;
+}
+function createTempVariableGenerator() {
+    let i = 0;
+    return () => `__temp${i++}`;
+}
+function replaceBlockingCalls(generateName, expression) {
+    function replaceBlockingFunctionInvocations(ex) {
+        if (ex.tag !== 'functionInvocation') {
+            return ex;
+        }
+        const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
+        if (blockingCallArgumentNames) {
+            const nameAndValue = R.zip(blockingCallArgumentNames, ex.arguments);
+            const callArgs = R.fromPairs(nameAndValue);
+            const tempCallResultVariable = generateName();
+            callStatements.push(new FunctionInvocationStatement(ex.functionName, callArgs, tempCallResultVariable));
+            // replace function invocation with a reference to the temporary variable
+            return variableReferenceEx(tempCallResultVariable);
+        }
+        else {
+            return ex;
+        }
+    }
+    const callStatements = [];
+    return [
+        callStatements,
+        transformExpression(replaceBlockingFunctionInvocations, expression),
+    ];
+}
+/**
+ * Search for blocking calls in expressions and replace them with a call + variable.
+ *
+ * The Workflows runtime requires that blocking calls must be executed by a call step.
+ *
+ * For example, transforms this:
+ *
+ * ```yaml
+ * - return1:
+ *     return: ${http.get("https://example.com")}
+ * ```
+ *
+ * into this:
+ *
+ * ```yaml
+ * - call_http_get_1:
+ *     call: http.get
+ *     args:
+ *       url: https://example.com
+ *     result: __temp0
+ * - return1:
+ *     return: ${__temp0}
+ * ```
+ */
+function blockingCallsAsFunctionCalls(generateTempName) {
+    return (statement) => {
+        return expandExpressionToStatements((ex) => replaceBlockingCalls(generateTempName, ex), statement);
+    };
 }
 /**
  * Apply transform to expressions recursively.
- * Transform leaf expresionssins first.
+ * Transform leaf expressions first.
  */
 function transformExpression(transform, ex) {
-    return transform(transformNestedExpressions(transform, ex));
-}
-function transformNestedExpressions(transform, ex) {
-    const tr = (y) => transformExpression(transform, y);
-    switch (ex.expressionType) {
-        case 'primitive':
-            if (isLiteral(ex)) {
-                return ex;
-            }
-            else {
-                const newPrimitive = transformPrimitive(transform, ex.value);
-                return newPrimitive === ex.value
-                    ? ex
-                    : new PrimitiveExpression(newPrimitive);
-            }
-        case 'binary':
-            return new BinaryExpression(tr(ex.left), ex.binaryOperator, tr(ex.right));
+    const nestedTr = (y) => transformExpression(transform, y);
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
         case 'variableReference':
-            return ex;
+            return transform(ex);
+        case 'list':
+            return transform(listEx(R.map(nestedTr, ex.value)));
+        case 'map':
+            return transform(mapEx(R.map(nestedTr, ex.value)));
+        case 'binary':
+            return transform(binaryEx(nestedTr(ex.left), ex.binaryOperator, nestedTr(ex.right)));
         case 'functionInvocation':
-            return new FunctionInvocationExpression(ex.functionName, ex.arguments.map(tr));
+            return transform(functionInvocationEx(ex.functionName, ex.arguments.map(nestedTr)));
         case 'member':
-            return new MemberExpression(tr(ex.object), tr(ex.property), ex.computed);
+            return transform(memberEx(nestedTr(ex.object), nestedTr(ex.property), ex.computed));
         case 'unary':
-            return new UnaryExpression(ex.operator, tr(ex.value));
-    }
-}
-function transformPrimitive(transform, val) {
-    const tranformVal = R.ifElse(isExpression, (x) => transformExpression(transform, x), (x) => transformPrimitive(transform, x));
-    if (Array.isArray(val)) {
-        return R.map(tranformVal, val);
-    }
-    else if (isRecord(val)) {
-        return R.map(tranformVal, val);
-    }
-    else {
-        return val;
+            return transform(unaryEx(ex.operator, nestedTr(ex.value)));
     }
 }
 /**
- * Search for map literals in expressions and replace them with assign step + variable.
+ * Search for map literals in expressions and replace them with assign + variable.
  *
  * Workflows does not support a map literal in expressions.
  *
  * For example, transforms this:
  *
+ * ```yaml
  * - return1:
  *     return: ${ {value: 5}.value }
+ * ```
  *
  * into this:
  *
+ * ```yaml
  * - assign1:
  *     assign:
  *       - __temp0:
- *         value: 5
+ *           value: 5
  * - return1:
  *     return: ${__temp0.value}
+ * ```
  */
-function mapLiteralsAsAssignSteps(steps) {
-    const transformNestedMapsInExpressions = transformStepExpressions(transformNestedMaps);
-    return R.chain(transformNestedMapsInExpressions, steps);
+function mapLiteralsAsAssigns(generateTempName) {
+    return (statement) => {
+        return expandExpressionToStatements((ex) => transformNestedMaps(generateTempName, ex), statement);
+    };
 }
-function transformNestedMaps(ex) {
-    const generateTemporaryVariableName = createTempVariableGenerator();
-    const { transformedExpression, tempVariables } = extractNestedMaps(ex, generateTemporaryVariableName, 0);
-    const assignments = tempVariables.length > 0 ? [new AssignStepAST(tempVariables)] : [];
+function transformNestedMaps(generateTempName, ex) {
+    const { transformedExpression, tempVariables } = extractNestedMaps(ex, generateTempName, 0);
+    const assignments = tempVariables.length > 0 ? [new AssignStatement(tempVariables)] : [];
     return [assignments, transformedExpression];
 }
 function extractNestedMaps(ex, generateName, nestingLevel) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return extractNestedMapPrimitive(ex.value, generateName, nestingLevel);
-        case 'binary':
-            return extractNestedMapBinary(ex, generateName, nestingLevel);
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
         case 'variableReference':
             return { transformedExpression: ex, tempVariables: [] };
+        case 'list':
+            return extractMapsInList(ex, generateName, nestingLevel);
+        case 'map':
+            return extractMapsInMap(ex, generateName, nestingLevel);
+        case 'binary':
+            return extractNestedMapBinary(ex, generateName, nestingLevel);
         case 'functionInvocation':
             return extractNestedMapFunctionInvocation(ex, generateName, nestingLevel);
         case 'member':
@@ -345,64 +334,24 @@ function extractNestedMaps(ex, generateName, nestingLevel) {
             return extractNestedMapUnary(ex, generateName, nestingLevel);
     }
 }
-function extractNestedMapPrimitive(primitiveEx, generateName, nestingLevel) {
-    const { transformed, tempVariables } = extractNestedMapPrimitiveRecursive(primitiveEx, generateName, nestingLevel);
-    return {
-        transformedExpression: asExpression(transformed),
-        tempVariables,
-    };
-}
-function extractNestedMapPrimitiveRecursive(primitiveEx, generateName, nestingLevel) {
-    if (typeof primitiveEx === 'string' ||
-        typeof primitiveEx === 'number' ||
-        typeof primitiveEx === 'boolean' ||
-        primitiveEx === null) {
-        return {
-            transformed: primitiveEx,
-            tempVariables: [],
-        };
-    }
-    else if (Array.isArray(primitiveEx)) {
-        return extractMapsInList(primitiveEx, generateName, nestingLevel);
-    }
-    else {
-        return extractMapsInMap(primitiveEx, generateName, nestingLevel);
-    }
-}
-function extractMapsInList(primitiveEx, generateName, nestingLevel) {
-    const { tempVariables, elements } = primitiveEx.reduce((acc, val) => {
-        if (isExpression(val)) {
-            const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, nestingLevel);
-            acc.tempVariables.push(...temps);
-            acc.elements.push(transformedExpression);
-        }
-        else {
-            const { transformed, tempVariables: temps } = extractNestedMapPrimitiveRecursive(val, generateName, nestingLevel);
-            acc.tempVariables.push(...temps);
-            acc.elements.push(transformed);
-        }
-        return acc;
-    }, {
-        tempVariables: [],
-        elements: [],
+function extractMapsInList(list, generateName, nestingLevel) {
+    const tempVariables = [];
+    const elements = [];
+    list.value.forEach((val) => {
+        const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, nestingLevel);
+        tempVariables.push(...temps);
+        elements.push(transformedExpression);
     });
     return {
         tempVariables,
-        transformed: elements,
+        transformedExpression: listEx(elements),
     };
 }
-function extractMapsInMap(primitiveEx, generateName, nestingLevel) {
-    const { tempVariables, properties } = Object.entries(primitiveEx).reduce((acc, [key, val]) => {
-        if (isExpression(val)) {
-            const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, 0);
-            acc.tempVariables.push(...temps);
-            acc.properties[key] = transformedExpression;
-        }
-        else {
-            const { transformed, tempVariables: temps } = extractNestedMapPrimitiveRecursive(val, generateName, 0);
-            acc.tempVariables.push(...temps);
-            acc.properties[key] = transformed;
-        }
+function extractMapsInMap(map, generateName, nestingLevel) {
+    const { tempVariables, properties } = Object.entries(map.value).reduce((acc, [key, val]) => {
+        const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, 0);
+        acc.tempVariables.push(...temps);
+        acc.properties[key] = transformedExpression;
         return acc;
     }, {
         tempVariables: [],
@@ -410,17 +359,17 @@ function extractMapsInMap(primitiveEx, generateName, nestingLevel) {
     });
     let newValue;
     if (nestingLevel === 0) {
-        newValue = properties;
+        newValue = mapEx(properties);
     }
     else {
-        newValue = new VariableReferenceExpression(generateName());
+        newValue = variableReferenceEx(generateName());
         tempVariables.push({
             name: newValue,
-            value: new PrimitiveExpression(properties),
+            value: mapEx(properties),
         });
     }
     return {
-        transformed: newValue,
+        transformedExpression: newValue,
         tempVariables,
     };
 }
@@ -432,7 +381,7 @@ function extractNestedMapFunctionInvocation(ex, generateName, nestingLevel) {
         return acc;
     }, { expressions: [], temps: [] });
     return {
-        transformedExpression: new FunctionInvocationExpression(ex.functionName, expressions),
+        transformedExpression: functionInvocationEx(ex.functionName, expressions),
         tempVariables: temps,
     };
 }
@@ -440,7 +389,7 @@ function extractNestedMapBinary(ex, generateName, nestingLevel) {
     const left = extractNestedMaps(ex.left, generateName, nestingLevel + 1);
     const right = extractNestedMaps(ex.right, generateName, nestingLevel + 1);
     return {
-        transformedExpression: new BinaryExpression(left.transformedExpression, ex.binaryOperator, right.transformedExpression),
+        transformedExpression: binaryEx(left.transformedExpression, ex.binaryOperator, right.transformedExpression),
         tempVariables: left.tempVariables.concat(right.tempVariables),
     };
 }
@@ -448,31 +397,27 @@ function extractNestedMapMember(ex, generateName, nestingLevel) {
     const obj = extractNestedMaps(ex.object, generateName, nestingLevel + 1);
     const pr = extractNestedMaps(ex.property, generateName, nestingLevel + 1);
     return {
-        transformedExpression: new MemberExpression(obj.transformedExpression, pr.transformedExpression, ex.computed),
+        transformedExpression: memberEx(obj.transformedExpression, pr.transformedExpression, ex.computed),
         tempVariables: obj.tempVariables.concat(pr.tempVariables),
     };
 }
 function extractNestedMapUnary(ex, generateName, nestingLevel) {
     const { transformedExpression, tempVariables } = extractNestedMaps(ex.value, generateName, nestingLevel);
     return {
-        transformedExpression: new UnaryExpression(ex.operator, transformedExpression),
+        transformedExpression: unaryEx(ex.operator, transformedExpression),
         tempVariables,
     };
 }
 /**
  * Replace `Array.isArray(x)` with `get_type(x) == "list"`
  */
-function intrinsicFunctionImplementation(steps) {
-    const tr = transformStepExpressions((ex) => [
-        [],
-        transformExpression(replaceIsArray, ex),
-    ]);
-    return R.chain(tr, steps);
-}
+const intrinsicFunctionImplementation = expandExpressionToStatements((ex) => [
+    [],
+    transformExpression(replaceIsArray, ex),
+]);
 function replaceIsArray(ex) {
-    if (ex.expressionType === 'functionInvocation' &&
-        ex.functionName === 'Array.isArray') {
-        return new BinaryExpression(new FunctionInvocationExpression('get_type', ex.arguments), '==', new PrimitiveExpression('list'));
+    if (ex.tag === 'functionInvocation' && ex.functionName === 'Array.isArray') {
+        return binaryEx(functionInvocationEx('get_type', ex.arguments), '==', stringEx('list'));
     }
     else {
         return ex;