build-expression-tree

name	build-expression-tree
description	For symbolic computation: ASTs, mathematical expressions, code that manipulates code structure, expression transformations.

build-expression-tree

When to Use

• Symbolic math (differentiation, simplification)
• Building ASTs for interpreters
• Query builders (SQL, API)
• Code generation
• Expression pattern matching

When NOT to Use

• Just need to evaluate once (use direct computation)
• No transformation needed
• Structure too complex (use existing parser)

The Pattern

Represent expressions as nested data structures (tuples, classes, or trees).

# Tuple representation
expr = ('+', ('*', 'x', 2), 1)  # (x * 2) + 1

# Class representation
class Expr:
    def __init__(self, op, *args):
        self.op, self.args = op, args

    def __add__(self, other):
        return Expr('+', self, other)

    def __mul__(self, other):
        return Expr('*', self, other)

x = Expr('x')
expr = x * 2 + 1  # Builds expression tree

# Recursive evaluation
def evaluate(expr, env):
    if isinstance(expr, str):
        return env[expr]  # Variable lookup
    if isinstance(expr, (int, float)):
        return expr
    op, *args = expr if isinstance(expr, tuple) else (expr.op, *expr.args)
    values = [evaluate(a, env) for a in args]
    return {'+': lambda a,b: a+b, '*': lambda a,b: a*b}[op](*values)

Example (from pytudes Differentiation.ipynb)

class Expression:
    """A symbolic mathematical expression."""
    def __init__(self, op, *args):
        self.op, self.args = op, args

    def __add__(self, other):  return Expression('+', self, other)
    def __radd__(self, other): return Expression('+', other, self)
    def __mul__(self, other):  return Expression('*', self, other)
    def __rmul__(self, other): return Expression('*', other, self)
    def __neg__(self):         return Expression('-', self)

    def __repr__(self):
        if len(self.args) == 1:
            return f"({self.op}{self.args[0]})"
        return 

 ():
    
     ():
         Expression(, x)


x = Expression()
sin, cos = Function(), Function()


expr = sin(x) + cos(x) * 



 ():
    
     y == x:  
      (y, Expression):  
    op, args = y.op, y.args
     op == :  D(args[], x) + D(args[], x)
     op == :  D(args[], x) * args[] + args[] * D(args[], x)
     op == sin:  cos(args[]) * D(args[], x)
    

Key Principles

1. Operator overloading: Natural syntax for building trees
2. radd/rmul for commutativity: Handle 2 + x not just x + 2
3. Recursive processing: Walk tree to evaluate/transform
4. Pattern matching on op: Different behavior per operation
5. Simplification rules: Reduce 0 + x to x, etc.