How to code-gen unrolled loop over a tuple?

General Usage
,
10 
module TupleTail
    export tuple_tail
    function vararg_tail((@nospecialize unused), r...)
        r
    end
    # More or less equivalent to `Base.tail`
    function tuple_tail(@nospecialize t::Tuple{Any,Vararg})
        r = vararg_tail(t...)::Tuple
        if t isa NTuple
            r = r::NTuple
        end
        r
    end
end

# Taken from my in-development package HeterogeneousLists.jl
#
# Not all of the code in the module is necessary here.
module TypeDomainNaturalNumbers

export NonnegativeInteger, PositiveInteger, natural_successor, natural_predecessor

using ..TupleTail

abstract type AbstractNonnegativeInteger end

"""
    NonnegativeInteger

Nonnegative integers in the type domain.

The implementation is inspired by the Zermelo construction of the natural numbers.
"""
struct NonnegativeIntegerImpl{
    Predecessor<:Union{Nothing,AbstractNonnegativeInteger},
} <: AbstractNonnegativeInteger
    predecessor::Predecessor

    global const NonnegativeInteger = NonnegativeIntegerImpl{P} where {
        P<:Union{Nothing,NonnegativeIntegerImpl},
    }

    global function new_nonnegative_integer(p::P) where {P<:Union{Nothing,NonnegativeInteger}}
        t_p = P::DataType
        r = new{t_p}(p)
        r::NonnegativeInteger
    end
end

"""
    PositiveInteger

Positive integers in the type domain.
"""
const PositiveInteger = let t = NonnegativeInteger
    t{<:t}
end::Type{<:NonnegativeInteger}

"""
    natural_successor(::NonnegativeInteger)

Return the successor of a natural number.
"""
function natural_successor(o::NonnegativeInteger)
    new_nonnegative_integer(o)::PositiveInteger
end

"""
    natural_predecessor(::PositiveInteger)

Return the predecessor of a nonzero natural number.
"""
function natural_predecessor(o::PositiveInteger)
    o.predecessor::NonnegativeInteger
end

function Base.zero(::Type{NonnegativeInteger})
    new_nonnegative_integer(nothing)
end

Base.@assume_effects :foldable function to_int(@nospecialize o::NonnegativeInteger)
    if o isa PositiveInteger
        let p = natural_predecessor(o), t = @inline to_int(p)
            t::Int + 1
        end
    else
        0
    end::Int
end

function Base.convert(::Type{Int}, o::NonnegativeInteger)
    to_int(o)
end

const negative_error = ArgumentError("can't convert negative to natural")

Base.@assume_effects :foldable function from_val(::Val{N}) where {N}
    n = N::Int
    if n < 0
        throw(negative_error)
    end
    if n === 0
        zero(NonnegativeInteger)
    else
        let v = Val{n - 1}(), p = @inline from_val(v)
            natural_successor(p::NonnegativeInteger)
        end
    end::NonnegativeInteger
end

function from_int(n::Int)
    if n < 0
        throw(negative_error)
    end
    if n === 0
        zero(NonnegativeInteger)
    else
        from_val(Val{n}())
    end::NonnegativeInteger
end

function Base.convert(::Type{NonnegativeInteger}, n::Int)
    from_int(n)
end

Base.@assume_effects :foldable function subtracted((@nospecialize l::NonnegativeInteger), @nospecialize r::NonnegativeInteger)
    if r isa PositiveInteger
        let a = natural_predecessor(l), b = natural_predecessor(r)
            @inline subtracted(a, b)
        end
    else
        l
    end::NonnegativeInteger
end

Base.@assume_effects :foldable function added((@nospecialize l::NonnegativeInteger), @nospecialize r::NonnegativeInteger)
    if r isa PositiveInteger
        let a = natural_successor(l), b = natural_predecessor(r)
            @inline added(a, b)
        end
    else
        l
    end::NonnegativeInteger
end

function Base.:(-)((@nospecialize l::NonnegativeInteger), @nospecialize r::NonnegativeInteger)
    subtracted(l, r)
end


function Base.:(+)((@nospecialize l::NonnegativeInteger), @nospecialize r::NonnegativeInteger)
    added(l, r)
end

end

module TupleUtils

using ..TypeDomainNaturalNumbers

export natural_tuple_length, tuple_element_at_index

"""
    natural_tuple_length(::Tuple)

Return a nonnegative integer which is the length of the given tuple.
"""
Base.@assume_effects :foldable function natural_tuple_length(@nospecialize t::Tuple)
    if t === ()
        zero(NonnegativeInteger)
    else
        let a = tuple_tail(t), b = @inline natural_tuple_length(a)
            natural_successor(b::NonnegativeInteger)
        end
    end::NonnegativeInteger
end

function tuple_element_at_index(t::Tuple{Any,Vararg}, @nospecialize n::NonnegativeInteger)
    p = natural_successor(n)
    i = convert(Int, p)
    t[i]
end

end

module WeightedRandPickFromHeterogeneous

using ..TypeDomainNaturalNumbers, ..TupleUtils

export weighted_rand_pick_from_heterogeneous

function weighted_rand_pick_from_heterogeneous_recursive(
    rand::R,
    f::F,
    heterogeneous::Tuple{Any,Vararg},
    weights::Tuple,
    len::NonnegativeInteger,
    (@nospecialize n::NonnegativeInteger),
)
    i = len - n
    a = tuple_element_at_index(heterogeneous, i)
    if n isa PositiveInteger
        let heterogeneous = heterogeneous::Tuple{Any,Any,Vararg},
            weights = weights::Tuple{Any,Vararg},
            j = natural_predecessor(i),
            w = tuple_element_at_index(weights. j),
            x = rand()
            if x < w
                f(a)
            else
                let nm1 = natural_predecessor(n)
                    @inline weighted_rand_pick_from_heterogeneous_recursive(
                        rand, f, heterogeneous, weights, len, nm1,
                    )
                end::Nothing
            end
        end
    else
        f(a)
    end
    nothing
end

function weighted_rand_pick_from_heterogeneous(
    r::R, f::F, h::Tuple{Any,Vararg}, w::Tuple
) where {R,F}
    len = natural_tuple_length(w)
    weighted_rand_pick_from_heterogeneous_recursive(r, f, h, w, len)
end

end

function usefunc end

function pickfunc(data, funcs::Tuple{Any,Vararg}, cumweights::Tuple)
    f = let data = data, closure
        function closure(g::G) where {G}
            usefunc(data, g)
        end
    end
    weighted_rand_pick_from_heterogeneous(rand, f, funcs, cumweights)
end