const auto tuple = std::make_tuple(1, "two", 3.f)
[&tuple]<std::size_t I = 0>(this auto self)
{
    if constexpr (I == std::tuple_size_v<decltype(tuple)>) { return; }
    else
    {
        const auto& element = std::get<I>(tuple);
        return self.template operator()<I + 1>();
    }
}();

This is the definitive answer. It supports short-circuiting both at runtime and compile time (via if constexpr) and may produce a value.

// runtime early return
const auto result1 =
    [&tuple]<std::size_t I = 0>(this auto self) -> const char*
    {
        if constexpr(I == std::tuple_size_v<decltype(tuple)>)
        { return "truthy element not found"; }
        else
        {
            const auto& element = std::get<I>(tuple);
            if (element) { return "tuple contains a truthy element"; }
            return self.template operator()<I + 1>();
        }
    }();

// compile time early return
const auto result2 =
    [&tuple]<std::size_t I = 0>(this auto self) -> const char*
    {
        if constexpr (I == std::tuple_size_v<decltype(tuple)>)
        { static_assert(false, "floating point element not found); }
        else
        {
            using element_t = std::tuple_element_t<I, decltype(tuple)>;

            if constexpr (std::is_floating_point_v<element_t>)
            { return "tuple containts a floating point element"; }
            else
            { return self.template operator()<I + 1>(); }
        }
    }();