overload-operators-dsl

name	overload-operators-dsl
description	For domain-specific languages: operator overloading, make Python look like math/domain notation, expression builders.

overload-operators-dsl

When to Use

• Mathematical DSL
• Query builders
• Expression builders
• Matrix operations
• Custom numeric types
• Making code look like domain notation

When NOT to Use

• Would be confusing to readers
• Standard operators have meaning already
• Single-use code

The Pattern

Implement __add__, __mul__, etc. to make operators build structure.

class Vector:
    def __init__(self, *components):
        self.components = components

    def __add__(self, other):
        return Vector(*(a + b for a, b in zip(self.components, other.components)))

    def __mul__(self, scalar):
        return Vector(*(c * scalar for c in self.components))

    def __rmul__(self, scalar):
        return self * scalar  # Handle 2 * v

v = Vector(1, 2, 3)
w = Vector(4, 5, 6)
result = 2 * v + w  # Vector math with natural syntax

Example (from pytudes Differentiation.ipynb)

class Expression:
    """DSL for symbolic math."""
    def __init__(self, op, *args):
        self.op, self.args = op, args

    # Arithmetic operators build expressions
    def __add__(self, other):  return Expression('+', self, other)
    def __radd__(self, other): return Expression('+', other, self)
    def __sub__(self, other):  return Expression('-', self, other)
    def __rsub__(self, other): return Expression('-', other, self)
    def __mul__(self, other):  return Expression('*', self, other)
    def __rmul__(self, other): return Expression('*', other, self)
    def __truediv__(self, other): return Expression('/', self, other)
    def __pow__(self, other):  return Expression('**', self, other)
    def __neg__(self):         return Expression('-', self)

    # Equality and hashing for use in dicts
    def __eq__(self, other):
        return (isinstance(other, Expression) and
                self.op == other.op and self.args == other.args)

    def __hash__(self):
        return hash((self.op, self.args))

# Create symbols
x, y, z = Expression('x'), Expression('y'), Expression('z')

# Natural mathematical syntax
polynomial = 3*x**2 + 2*x + 1
derivative = D(polynomial, x)  # 6*x + 2

# Simplification table uses expressions as keys
simp_table = {
    sin(0): 0,
    cos(0): 1,
    ln(1): 0,
}

Key Principles

1. Implement __r*__ methods: Handle 2 + x not just x + 2
2. Return new instances: Operators build structure, don't mutate
3. Implement __eq__ and __hash__: For use in sets/dicts
4. Readable __repr__: Show expression structure clearly
5. Match domain notation: Math DSL looks like math