__>const auto it = MyVerySpecialFoosMap.find();

__>if(it != MyVerySpecialFoosMap)
__>{
__>  <...>
__>};
__>

__>if(!it.is_at_the_end())
__>{
__>  <...>
__>};
__>

auto Find(const auto& oWhere, const auto& rWhat)
{
    return {oWhere.find(rWhat), oWhere.end()};
}

int main()
{
    std::map<std::string, int> oMap = { {"a", 1}, {"b", 2} };
    
    if ( const auto [it, itEnd] = Find(oMap, "a")); it != itEnd )
    {
    
    }
    return 0;
}

const auto it = MyVerySpecialFoosMap.find();

if(it != MyVerySpecialFoosMap)
{
  <...>
};

if(!it.is_at_the_end())
{
  <...>
};

__>if(!it.is_at_the_end())
__>{
__>  <...>
__>};
__>

if(auto x = find_value(some_map, value))
{
}

find_value(some_map, value, [](auto &x)
{
});

 const auto& c = myVeryLongContainerName;
 auto it = c.find(...)
 if (it != c.end())
 {
  ...
 }

template<class I>
auto ptr_from_iter(I i, I e) { return i == e ? nullptr : &*i; }

template<class I, class V>
auto find_from_to(I b, I e, V&& v) { return ptr_from_iter(std::find(b, e, v), e); }

// для контейнеров, у которых есть член find
template<class C, class V>
auto find_in(C&& c, V&& v) { return ptr_from_iter(c.find(v), end(c)); }

// для контейнеров, у которых find внешний
template<class C, class V>
auto find_over(C&& c, V&& v) { return find_from_to(begin(c), end(c), v); }

int main() {
  std::map<int,string> the_map = { {1,"hello"} };
  std::vector<int> the_vec = {3,5,1};

  for (int i=0; i<2; ++i) {
    std::cout << "looking for " << i << ":" << std::endl;
    if(auto p = find_in(the_map, i)) {
      std::cout << p->first << ":" << p->second << std::endl;
    } else {
      std::cout << "not found" << std::endl;
    }

    if(auto p = find_over(the_vec, i)) {
      std::cout << *p << std::endl;
    } else {
      std::cout << "not found" << std::endl;
    }
  }
}

http://www.stepanovpapers.com/notes.pdf
The result of my experiment was quite astonishing. The code did not contain serious bugs. There were typos: I had to change AND to OR, etc. But I did no
t need patches. And over 95% of the code was in general functions! I felt quite proud. There remained a problem that I could not yet precisely figure out what it meant that a function was general. As a matter of fact, it is possible to summarize my research over the next 30 years as an attempt to clarify this very point.

It is easy to overlook the importance of what I discovered. I did not discover that general functions could be used by other programmers. As a matter of fact, I did not think of other programmers. I did not even discover that I could use them later. The significant thing was that making interfaces general – even if I did not quite know what it meant – I made them much more robust. The changes in the surrounding code or changes in the grammar of the input language did not affect the general functions: 95% of the code was impervious to change. In other words: decomposing an application into a collection of general purpose algorithms and data structures makes it robust. (But even without generality, code is much more robust when it is decomposed into small functions with clean interfaces.) Later on, I discovered the following fact: as the size of application grows so does the percentage of the general code. I believe, for example, that in most modern desktop applications the non-general code should be well under 1%.

__>>или притаскивать буст

EP>>>В общем ты уже не знаешь до чего докопаться, всё мимо

__>>>>вот введут с++17, тогда проблема частично снимется, потому как можно будет использовать подход B0FEE664 (он намного проще и лаконичнее, чем написание библиотек)

EP>>>Опять мимо — вообще-то у него тоже пишется отдельная функция

__>>одна максимально(почти) общая простейшая функция вместо библиотеки

EP>И опять мимо Я тебя сразу сказал что достаточно простой функции обёртки. Несколько нужно для работы с разными концепциями контейнеров, и в случае как ты говоришь "подхода B0FEE664" — там также будет несколько функций

auto Find(const auto& oWhere, const auto& rWhat)
{
    return {oWhere.find(rWhat), oWhere.end()};
}

auto Find(const auto& oWhere, const auto& rWhat)
{
    return {std::find(oWhere.begin(), oWhere.end(), rWhat), oWhere.end()};
}

EP>>И опять мимо Я тебя сразу сказал что достаточно простой функции обёртки. Несколько нужно для работы с разными концепциями контейнеров, и в случае как ты говоришь "подхода B0FEE664" — там также будет несколько функций

auto find_value(auto &&m, const auto &x)
{
    auto p = m.find(x);
    return p == end(m) ? nullptr : &*p;
}