Staged specialization

Medium sketched @generated: the method sees types and returns an Expr. Expert work uses that to stage code — emit a different body per concrete signature, then let the compiler compile each specialization once.

Val{N} (and Val(N) values) smuggle a type-level constant into dispatch. A generated method on ::Val{N} can unroll a fixed-length loop into N statements when N is small and known at compile time.

Base.@assume_effects / effect annotations and careful purity matter: generated bodies must not observe runtime values. If you need a value, take it as a normal argument outside the generated path, or pass a Val that encodes the constant.

specialize / forcing specialization is usually automatic on concrete calls. Reach for @generated only when the shape of the code must change by type — field loads, unrolled tuples, static sizes — not for ordinary if on values.

Misses: reading runtime fields inside @generated, returning a non-Expr, or unrolling huge N so compile time explodes.

@generated function sum_tuple(t::NTuple{N,Any}) where {N}
    exs = [:(s += t[$i]) for i in 1:N]
    quote
        s = 0
        $(Expr(:block, exs...))
        s
    end
end

println(sum_tuple((1, 2, 3)))
println(sum_tuple((10, 20)))

@generated function pow2(::Val{N}) where {N}
    :($(2^N))
end

println(pow2(Val(8)))