STL-like palindrome checking
Nothing wrong with these:

template&lt;typename Iterator&gt;
using ItVType  = typename std::iterator_traits&lt;Iterator&gt;::value_type;

template&lt;typename Iterator&gt;
using StdEqual= typename std::equal_to&lt;ItVType&lt;Iterator&gt;&gt;;


But I find them a bit disturbing being so unbound (they are in the global namespace). Maybe just a feeling. I personally would put them in an anonymous namespace.

I also prefer

template&lt;typename BidirectionalIterator,
         typename Compare=StdEqual&lt;BidirectionalIterator&gt;&gt;
bool is_palindrome(BidirectionalIterator first,
                   BidirectionalIterator last, 
                   Compare               comp=Compare())


Over

template&lt;typename BidirectionalIterator,
         typename Compare&gt;
bool alt_is_palindrome(BidirectionalIterator first,
                       BidirectionalIterator last,
                       Compare               comp)

template&lt;typename BidirectionalIterator&gt;
inline bool alt_is_palindrome(BidirectionalIterator first,
                              BidirectionalIterator last)


Putting it all in one function does not reduce readability.
But the huge template type names do bother me slightly. Template names are usually short (because they are not real type).

template&lt;typename I,typename Compare=StdEqual&lt;I&gt;&gt;
  // requires BindirectionalIterator&lt;I&gt;()
bool is_palindrome(I first, I last,Compare comp=Compare())


I change my mind this is fine.

for(; first != last &amp;&amp; first != --last; ++first)
    if(not comp(*first,*last))
        return false;


But you may want to look at some algorithms.

return std::equal(first, last, std::reverse_iterator(last), comp);


Admittedly I now compare twice as many elements (so not an improvement in this case (informational only)). But if you are using random access elements you can reduce this by calculating the mid point manually.

auto dist    = std::distance(first, last);
auto halfway = first;
std::advance(halfway, dist/2);   
return std::equal(first, halfway, std::reverse_iterator(last), comp);


Looks like this should not compile:

 is_palindrome(begin(s),end(s))


That should be std::begin() and std::end() so it looks like you have a hidden using namespace std; somewhere.

If you are going to declare your lambda like this:

auto my_comp = [](auto const&amp; lhs, auto const&amp; rhs)
{
    return tolower(lhs) == std::tolower(rhs);
};


You may as well put it in a separate function. The point of lambdas is you can see them in place.

is_palindrome(begin(s),end(s),
              [](auto const&amp; lhs, auto const&amp; rhs) {return tolower(lhs) == std::tolower(rhs);}
             );