Compile time hash - confusion on template deduction order - c++11

Question

I have found this piece of code in other topic
template<size_t N, size_t I = 0>
struct hash_calc
{
static constexpr size_t apply(const char(&s)[N])
{
return (hash_calc < N, I + 1 >::apply(s) ^ s[I]) * 16777619u;
};
};
template<size_t N>
struct hash_calc<N, N>
{
static constexpr size_t apply(const char(&s)[N])
{
return 2166136261u;
};
};
template<size_t N>
constexpr size_t hash(const char(&s)[N])
{
return hash_calc<N>::apply(s);
}
First of all, I am totally confused why it does not end being an infinite recursive call? From what I understand, first hash_calc<N, I> is always going to call itself, what causes it to break at the hash_calc<N, N> when I reaches N? The template instantiation for hash_calc<N, I> does not fail when N == I.
Second - i tried to copy paste the hash_calc<N, N> struct over hash_calc<N, I> which causes compile error error: 'hash_calc' is not a class template struct hash_calc<N, N>. Why is that?!
Edit:
The modified code below does not compile under msvc nor gcc. I have just put one template over other. What happened?
template<size_t N>
struct hash_calc<N, N>
{
static constexpr size_t apply(const char(&s)[N])
{
return 2166136261u;
};
};
template<size_t N, size_t I = 0>
struct hash_calc
{
static constexpr size_t apply(const char(&s)[N])
{
return (hash_calc < N, I + 1 >::apply(s) ^ s[I]) * 16777619u;
};
};
template<size_t N>
constexpr size_t hashq(const char(&s)[N])
{
return hash_calc<N>::apply(s);
}

Answer 1

I am totally confused why it does not end being an infinite recursive call?
So let's look at it, step by step.
hashq<N>(const char(&s)[N]) calls hash_calc<N>::apply(s);.
That's:
template<size_t N, size_t I = 0>
struct hash_calc
{
static constexpr size_t apply(const char(&s)[N])
{
return (hash_calc < N, I + 1 >::apply(s) ^ s[I]) * 16777619u;
};
};
with I==0.
Now hash_calc < N, I + 1 >::apply(s) is called, with I==1, this goes on until I==N. That's when
template<size_t N>
struct hash_calc<N, N>
{
static constexpr size_t apply(const char(&s)[N])
{
return 2166136261u;
};
};
is called. And the recursion ends.
Why is that?!
template<size_t N, size_t I = 0>
struct hash_calc
{
static constexpr size_t apply(const char(&s)[N])
{
return (hash_calc < N, I + 1 >::apply(s) ^ s[I]) * 16777619u;
};
};
is the more general case, it handles any pair of <N,I>, whereas
template<size_t N>
struct hash_calc<N, N>
{
static constexpr size_t apply(const char(&s)[N])
{
return 2166136261u;
};
};
is its specialisation, it can only handle the case of <N,N>.
The compiler first needs the general case and then the specialiation.