_computed(__module__::Module, typeexpr::Expr)

the bulk of the work to compute the AST transform

find_struct_decl(block::Expr)

Locate a :struct decl inside a :block of expressions.

fulltype(::Type)

Fill in the computed type parameters for T (if applicable and possible)

getenv!(expr, tvars, defs)

replace anything that isn't computable by apply_type with a dummy type-variable

make_Type_expr(tname, decl_tvars)

make the ::Type{T} expression that is equivalent to the original type declaration

make_curly(expr)

given an apply-type expression (T or T{...}), return Expr(:curly, T, ...)

make_fulltype_expr(tname, decl_tvars, def)

compute the leaf T{def} expression that is equivalent for the new type declaration

make_new_expr(tname, decl_tvars, def)

compute the leaf T{...} expression that describes the new type declaration

rewrite_new!(expr, tname::Symbol, decl_tvars, def)

rewrite the constructors to capture only the intended values

@computed type

Allows declaration of a type expression where some of the fields types are arbitrary computed functions of other type parameters. It's suggested that those expressions be const (return the same value for the same inputs), but that is not essential.