import ast
    import numpy as np
    from pystaging import *

    def make_ufunc(op):
        @staging(debug=True)
        def ufunc(A, B):
            out = np.empty_like(A)
            for i in range(A.shape[0]):
                # Evaluate operation inline
                out[i] = escape[op(quote[A[i]], quote[B[i]])]
            return out
        return ufunc

    @staging
    def add(a, b):
        return quote[escape[a] + escape[b]]

    def build_ufunc():
        ufunc = make_ufunc(add)
        A = np.arange(10)
        B = np.arange(10)
        print(ufunc(A, B))

    op = add # doesn't understand cell variables yet :(
    build_ufunc()

    def ufunc(A, B):
        out = np.empty_like(A)
        for i in range(A.shape[0]):
            out[i] = (A[i] + B[i])
        return out

    [ 0  2  4  6  8 10 12 14 16 18]

pystaging makes sure the programs generated have a valid syntactic
structure.

quote and escape can be overridden to produce different code fragments
than Python ASTs. These overrides can also perform type checking or
verification where desired.

Typing that ensured generated code is well-typed if the code generator
is well-typed.

The elegance to override Python syntax and use custom quote and escape
syntax operators.

Persist objects across stages, e.g. persist a compile time constant object
to runtime. Only string, int, float, list, dict and AST objects (and compositions
thereof) can be persisted.

def square(x):
    return quote[x * x]

square(quote[a + 2]) # produces ((a + 2) * (a + 2))

No built-in support for rewrites or domain-specific optimizations. However, one
can take the AST or Python code object and apply these later.