Thanks for these interesting observations Vincent!

template<typename InputRange, typename OutputIterator, typename Predicate>
constexpr auto copy_if(InputRange& range,
                       OutputIterator out,
                       Predicate pred)
{
    // Enable ADL
    using std::begin;
    using std::end;
    return std::copy_if(begin(range), end(range), out, pred);
}

std::vector<int> v{1, 2, 3, 4, 5};
std::vector<int> o;

auto nonMutatingPredicate  = [](int  i) {return true;};
auto evilMutatingPredicate = [](int& i) {i = -1; return true;};

copy_if(v, std::back_inserter(o), nonMutatingPredicate);
copy_if(v, std::back_inserter(o), evilMutatingPredicate);

copy_if(std::as_const(v), std::back_inserter(o), nonMutatingPredicate);
//copy_if(std::as_const(v), std::back_inserter(o), evilMutatingPredicate); // error: binding reference of type 'int&' to 'const int' discards qualifiers

template 
inline auto findByConstRef(const InputRange& range, const T& value)
{
    return std::find(begin(range), end(range), value);
}

void testFindByConstRef()
{
    std::vector v {1, 2, 3, 4, 5};
    //*findByConstRef(v, 3) = -1; // error: assignment of read-only location
}

In the code above, most users would expect to be able to modify the range using the iterator returned by findByConstRef().

Because of this and problems like those pointed out in this article, I decided, for consistency, to never take a container by const reference in my wrapper.

The “obvious” alternative is to use forwarding references. However, forwarding references bind to temporary ranges. This can lead to potentially dangerous or unwanted behavior if the programmer is not careful.

template 
inline auto findByRefRef(InputRange&& range, const T& value)
{
    return std::find(begin(range), end(range), value);
}

std::vector getTempVec()
{
    return {1, 2, 3, 4, 5};
}

void testFindByRefRef()
{
    auto it = findByRefRef(getTempVec(), 3);
    *it = -1; // undefined behavior
}

In the classic, iterator-based STL, it is not possible to use temporary ranges anyway, because both begin() and end() must be called on the same range, forcing it to have a name. So I decided to avoid forwarding references too, and thus sacrificed the potential composability that comes with temporary ranges, unlike in the current ISO C++ proposal.

In the end, I chose to take ranges by reference. Because of template type deduction rules, const ranges are still usable, and their constness is preserved. However, it does not enforce an obviously const algorithm like find_if to not modify the range elements.

template 
inline auto findByRef(InputRange& range, const T& value)
{
    return std::find(begin(range), end(range), value);
}

std::vector getTempVec()
{
    return {1, 2, 3, 4, 5};
}

void testFindByRef()
{
    std::vector v {1, 2, 3, 4, 5};
    const std::vector cv {1, 2, 3, 4, 5};

    *findByRef(v, 3) = -1;
    //*findByRef(cv, 3) = -1;                // error: assignment of read-only location
    //*findByRef(getTempVec(), 3) = -1;      // error: cannot bind non-const lvalue reference to rvalue
}

You can play with the code here.