Giveth me thy easier user input in C++ - follow up
Redefinition of default arguments

First of all, you cannot redefine default arguments. From [dcl.fct.default], slightly abridging the example:


  A default argument shall not be redefined by a later declaration (not even to the same value). [ Example:

void m() {
    void f(int, int);     // has no defaults
    f(4);                 // error: wrong number of arguments
    void f(int, int = 5); // OK
    f(4);                 // OK, calls f(4, 5);
    void f(int, int = 5); // error: cannot redefine, even to
                          // same value
}

  
  —end example ]


So the definition of get_input should just be:

template &lt;typename TInput, typename TPrompt&gt;
TInput easy_input::get_input(
    const TPrompt&amp; prompt, 
    std::istream&amp; input_stream)
{ ... }


Otherwise, the code is ill-formed and should not compile (though apparently earlier versions of gcc happily allow this).

Include guards AND pragma

Given that you have include guards, it's unnecessary to additionally have the conditional #pragma once. If you don't want to unconditionally use the pragma, just stick with the include guards.

Default Prompt and Error

You use the error message in a single place - it'd be better to just write out the string literal there. It'll be easier to find when grepping through code, and there's no advantage I see in having the global constant. 

With the default prompt, rather than all the additional complexity of default arguments, I think it'd be simpler to just add an overload:

template &lt;typename TInput&gt;
TInput get_input(std::istream&amp; input_stream = std::cin);

template &lt;typename TInput, typename TPrompt&gt;
TInput get_input(const TPrompt&amp; prompt,
    std::istream&amp; input_stream = std::cin)
{
    std::cout &lt;&lt; prompt;
    return get_input&lt;TInput&gt;(input_stream);
}


Ultimately though...

My biggest takeaway from 5gon12eder's excellent answer to your original question was that there really isn't anything easy about this input, and it may just be easier to avoid it and stick to being explicit with the streams. 

Here's something this solution can't handle. Let's say I want to input two ints. I could write:

int a, b;
std::cout &lt;&lt; "$";
std::cin &gt;&gt; a &gt;&gt; b;


And end up doing something like:

$42 15


And that works. But if I tried to do:

int a = get_input&lt;int&gt;("$");
int b = get_input&lt;int&gt;();


and tried to input both on the same line... I'd get a lexical error since "42 15" isn't an int. Maybe you're OK with that? But it's limiting and sadly not easy. Then again, nothing IO related in C++ is really easy anyway.