How can I replicate `algorithm` header type functions?

Just like algorithms in algo header like
std::sort(std::begin(), std::end(), greater)
where greater is a bool func

I am trying to do the same for understanding as how it works actually.
So I am trying to do the same by
1 -> making a lambda func in a separate namespace
2 -> making a separate function like std::sort in other namespace
3 -> passing a vector and it supposed to return a pointer to the element to find

And i am getting error:

<source>: In function 'int main()':
<source>:41:22: error: no matching function for call to 'chk(std::vector<int>::iterator, std::vector<int>::iterator, lambda::<lambda(auto:16, int)>&, int)'
   41 |     auto l {test::chk(series.begin(), series.end(), lambda::find, 50)};
      |             ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:22:10: note: candidate: 'template<class auto:17, class auto:18, class auto:19> auto test::chk(auto:17, auto:18, std::function<bool(auto:19, int)>&, int)'
   22 |     auto chk(auto start, auto end, std::function<bool (auto, int)>& find, int what)
      |          ^~~
<source>:22:10: note:   template argument deduction/substitution failed:
<source>:41:22: note:   'lambda::<lambda(auto:16, int)>' is not derived from 'std::function<bool(auto:19, int)>'
   41 |     auto l {test::chk(series.begin(), series.end(), lambda::find, 50)};
      |             ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

As per the error I tried putting std::iterator at chk func call at line no 41 but it gives even more error

help me with this

code:

#include <iostream>
#include <vector>
#include <algorithm>    //
#include <functional>    //std::function
#include <iterator>     //std::iterator

using vec = std::vector<int>;

namespace lambda
{
    auto find{
        [](auto start, int what) -> bool
        {
            if(*start == what)
                return true;
        }
    };
};

namespace test
{
    auto chk(auto start, auto end, std::function<bool (auto, int)>& find, int what)
    {
        if(start == end)
            return end;
            
        for(;start != end; ++start)
        {
            if(find(start, what))
                return start;
        }
        
        return end;     //is this really necessary?
    }
};

int main()
{
    vec series{1, 2, 3, 4, 5, 6, 7, 50, 8, 9, 10, 11, 12};
    
    auto l {test::chk(series.begin(), series.end(), lambda::find, 50)};
    
    //test
    std::cout << "Old array\n";
    
    for(int x: series)
        std::cout << x << ' ';
        
    std::cout << "\nNew array\n";
    
    *l = 666;
    
    for(int x: series)
        std::cout << x << ' ';
}

By using auto you end up with each parameter having a different type and the compiler has no way to deduce what all of the parameters should be (see the template argument deduction/substitution failed part of the error message).

Replacing the auto with normal templates gives:

template <typename A>
bool find =
[](A start, int what) ...
template <typename B, typename C, typename D, typename E>
E chk(A start, B end, std::function<bool (C, int)>& find, int what);

The compiler has no way to know that A, B, C, D and E should all be the same type.
If you change chk to:

template< typename Iterator >
Iterator chk(Iterator start, Iterator end, std::function<bool (Iterator, int)>& find, int what)

We're closer but still have two issues:

1. You're taking find by a non-const reference so the types have to match exactly
2. The compiler still can't deduce the type required for the find lambda as std::function prevents this kind of type deduction.

If we change to the more conventional form of the std algorithms of just taking the predicate as a template:

template< typename Iterator, typename Predicate >
Iterator chk(Iterator start, Iterator end, Predicate find, int what)

Then your code compiles. This has the added benefit of not involving the overhead of std::function and will use (and probably inline) the lambda directly.

You can use a concept to restrict the type of Predicate to match your requirements to improve compiler errors if used with an incorrect predicate.

find only ever returns true, you need to return in all cases otherwise your code has undefined behaviour:

auto find{
[](auto start, int what) -> bool
{
if(*start == what)
return true;
else
return false;
}

Or more simply:

auto find{
[](auto start, int what) -> bool
{
return *start == what;
}

Finally your predicate is unusual for a std algorithm in that it takes an iterator rather than a value, changing it to a value results in:

namespace lambda
{
auto find{
[](int value, int what)
{
return value == what;
}
};
};
namespace test
{
template< typename Iterator, typename Predicate >
Iterator chk(Iterator start, Iterator end, Predicate find, int what)
{
for(;start != end; ++start)
{
if(find(*start, what))
return start;
}
return end;
}
};

Note I've also removed the start == end check as it's unnecessary.