Instancias redundantes en expresiones constantes booleanas

tengo un n-cualquier booleano OR función de tiempo de ejecución any_run

#include <assert.h>

bool any_run() { return false; }

template <typename... B>
bool any_run(bool a, B... b)
{
    assert(a);
    return a || any_run(b...);
}

así como un análogo en tiempo de compilación any_comp

#include <type_traits>

template <bool E>
using expr = std::integral_constant <bool, E>;

using _true  = expr <true>;
using _false = expr <false>;

template <typename... A>
struct any_comp : public _false { };

template <typename A, typename... B>
struct any_comp <A, B...> : public expr <A() || any_comp <B...>()>
{
    static_assert(A(), "");
};

ambos contienen aserciones (en tiempo de ejecución o en tiempo de compilación, respectivamente) para garantizar que el primer argumento sea verdadero.

Ahora dando la siguiente entrada

int main()
{
    any_run   (true,  false,  false);
    any_comp <_true, _false, _false>();
}

la aserción en tiempo de ejecución nunca falla, pero la de tiempo de compilación sí. Esto significa que any_run(false, false) nunca se llama, sin embargo any_comp <_false, _false> se instancia, a pesar del hecho de que la expresión constante booleana

A() || any_comp <B...>()

podría ser evaluado para true if A() == true sin instanciar nunca any_comp <B...>.

Mi pregunta es si este experimento y su conclusión son válidos, y qué diría la norma al respecto.

Es importante porque si la conclusión es válida, tendría que volver a implementar varias funciones en tiempo de compilación con más cuidado (con más especializaciones) para que la compilación sea más rápida, aunque generalmente prefiero mantener las cosas lo más simples posible.