Skip to content

Expression trees for TypeScript similar to C#. Expression trees represent code in a tree-like data structure, where each node is an expression, for example, a method call or a binary operation such as x < y.

License

Notifications You must be signed in to change notification settings

Hookyns/tst-expression

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

27 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

C# Like Expression<> for TypeScript (tst-expression)

NPM version NPM version License: MIT

Readme Card

Expression trees for TypeScript similar to C#.

Expression trees represent code in a tree-like data structure, where each node is an expression, for example, a method call or a binary operation such as x < y.

You can compile and run code represented by expression trees. This enables dynamic operations over compiled code, with access to the context captured by the code.

How to Start

  • Install transformer package and ttypescript npm i tst-expression-transformer ttypescript -D,
  • install runtime package npm i tst-expression,
  • update tsconfig.json file,
{
    "compilerOptions": {
        // add tst-expression-transformer plugin
        "plugins": [
            {
                "transform": "tst-expression-transformer"
            }
        ]
    }
}
  • if You use Webpack, modify the webpack config,
({
    test: /\.(tsx?)$/,
    loader: "ts-loader",
    options: {
        compiler: "ttypescript"
    }
})
  • write Your code,
  • compile via npx ttsc,
  • run the code.

Expression<>

type Expression<TType> = {
    /**
     * Compiled executable expression.
     */
    compiled: TType;

    /**
     * Expression tree.
     */
    expression: ExpressionNode;

    /**
     * Captured context variables used in expression.
     */
    context: { [capturedVariableName: string]: any };
}

Usage

You can use Expression<> as type of method or function parameters. Transformer tst-expression-transformer handle all calls of those functions and methods and result is the Expression object with AST, compiled expression and captured context used by the expression.

Thanks to runtime package tst-expression, You have typing support with set of type guards, so You can traverse the expression safely.

Simple example, which returns array with name of variable and its value.

import { assertIdentifier, assertExpression, Expression } from "tst-expression";

const someVariable = 5;
const entry = getEntry(someVariable);

console.log(entry); // [ 'someVariable', 5 ]

function getEntry(expression: Expression<number>): [name: string, value: number] {
    assertExpression(expression);
    assertIdentifier(expression.expression);

    return [expression.expression.escapedText, expression.compiled];
}

Example

A little more complex example which takes expression of some math operations and logs the operation with its result.

Result of the example is: someVariable(5) + 5 - PI(3.141592653589793) = 6.858407346410207

import { 
    assertBinaryExpression, assertExpression, Expression, ExpressionKind, ExpressionNode, 
    isBinaryExpression, isNumericLiteral, isIdentifier, isPropertyAccessExpression 
} from "tst-expression";

const someVariable = 5;
logMathOperation(someVariable + 5 - Math.PI);

function logMathOperation(operationExpression: Expression<number>) {
    assertExpression(operationExpression);
    assertBinaryExpression(operationExpression.expression);

    const parts = splitBinaryExpressions(operationExpression.expression);
    let operation = "";

    for (const part of parts) {
        if (typeof (part) == "string") {
            operation += part;
        } else if (isNumericLiteral(part)) {
            operation += part.text;
        } else if (isIdentifier(part)) {
            operation += part.escapedText + `(${operationExpression.context[part.escapedText]})`;
        } else if (isPropertyAccessExpression(part)) {
            if (isIdentifier(part.expression) && isIdentifier(part.name)) {
                operation += part.name.escapedText + `(${operationExpression.context[part.expression.escapedText][part.name.escapedText]})`;
            } else {
                throw new Error("Not implemented.");
            }
        }
    }
    
    console.log(operation, "=", operationExpression.compiled);
}

function splitBinaryExpressions(expression: any): Array<ExpressionNode | string> {
    if (isBinaryExpression(expression)) {
        return [
            ...splitBinaryExpressions(expression.left),
            " " + getOperator(expression.operatorToken) + " ",
            ...splitBinaryExpressions(expression.right)
        ];
    }

    return [expression];
}

function getOperator(operatorToken: ExpressionNode): string {
    return ({
        [ExpressionKind.PlusToken]: "+",
        [ExpressionKind.MinusToken]: "-",
        [ExpressionKind.SlashToken]: "/",
        [ExpressionKind.AsteriskToken]: "*"
    } as { [kind: number]: string })[operatorToken.kind];
}

Transpiled code:

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tst_expression_1 = require("tst-expression");
const someVariable = 5;
logMathOperation({ compiled: someVariable + 5 - Math.PI, context: { someVariable, Math }, expression: {
        "flags": 0, "kind": 219, "left": { "flags": 0, "kind": 219, "left": { "flags": 0, "kind": 79, "escapedText": "someVariable" }, "operatorToken": { "flags": 0, "kind": 39 }, "right": { "flags": 0, "kind": 8, "text": "5", "numericLiteralFlags": 0 } }, "operatorToken": { "flags": 0, "kind": 40 }, "right": { "flags": 0, "kind": 204, "expression": { "flags": 0, "kind": 79, "escapedText": "Math" }, "name": { "flags": 0, "kind": 79, "escapedText": "PI" } } } });
function logMathOperation(operationExpression) {
    (0, tst_expression_1.assertExpression)(operationExpression);
    (0, tst_expression_1.assertBinaryExpression)(operationExpression.expression);
    const parts = splitBinaryExpressions(operationExpression.expression);
    let operation = "";
    for (const part of parts) {
        if (typeof (part) == "string") {
            operation += part;
        }
        else if ((0, tst_expression_1.isNumericLiteral)(part)) {
            operation += part.text;
        }
        else if ((0, tst_expression_1.isIdentifier)(part)) {
            operation += part.escapedText + `(${operationExpression.context[part.escapedText]})`;
        }
        else if ((0, tst_expression_1.isPropertyAccessExpression)(part)) {
            if ((0, tst_expression_1.isIdentifier)(part.expression) && (0, tst_expression_1.isIdentifier)(part.name)) {
                operation += part.name.escapedText + `(${operationExpression.context[part.expression.escapedText][part.name.escapedText]})`;
            }
            else {
                throw new Error("Not implemented.");
            }
        }
    }
    console.log(operation, "=", operationExpression.compiled);
}
function splitBinaryExpressions(expression) {
    if ((0, tst_expression_1.isBinaryExpression)(expression)) {
        return [
            ...splitBinaryExpressions(expression.left),
            " " + getOperator(expression.operatorToken) + " ",
            ...splitBinaryExpressions(expression.right)
        ];
    }
    return [expression];
}
function getOperator(operatorToken) {
    return {
        [tst_expression_1.ExpressionKind.PlusToken]: "+",
        [tst_expression_1.ExpressionKind.MinusToken]: "-",
        [tst_expression_1.ExpressionKind.SlashToken]: "/",
        [tst_expression_1.ExpressionKind.AsteriskToken]: "*"
    }[operatorToken.kind];
}

Tip

For work with AST you can use https://astexplorer.net which prints tree nicely. Use the TypeScript AST.

License

This project is licensed under the MIT license.

About

Expression trees for TypeScript similar to C#. Expression trees represent code in a tree-like data structure, where each node is an expression, for example, a method call or a binary operation such as x < y.

Topics

Resources

License

Stars

Watchers

Forks

Packages

No packages published