Add the version of find_backward() that is actually going in to the s…

doc/algorithm.qbk

@@ -110,6 +110,15 @@ Apply a functor to the elements of a sequence
 
 [endsect:CXX17]
 
+[section:CXX23 C++23 Algorithms]
+
+[section:CXX23_inner_algorithms]
+
+[include find_last.qbk]
+
+[endsect:CXX23_inner_algorithms]
+
+[endsect:CXX23]
 
 [section:Misc Other Algorithms]
 

doc/find_last.qbk

@@ -0,0 +1,96 @@
+[/ File find_last.qbk]
+
+[section:find_last find_last, find_last_if, find_last_if_not ]
+
+[/license
+Copyright (c) 2022 T. Zachary Laine
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'find_last.hpp' contains variants of the stl algorithm
+`find`. These variants are like `find`, except that they find the last
+instance of an element instead of the first.
+
+The functions in this header are as close to the ones in C++23's `std::ranges`
+namespace as possible.  In C++20 builds, they are constrained exactly as the
+standard does it.  They each return a `boost::algorithm::subrange`, which is a
+mostly-API-compatible version of `std::ranges::subrange`.  It's differences
+from the C++20 `subrange` are that it does not support sized ranges, and that
+it cannot be implicitly converted to a pair-like type.
+
+[heading interface]
+
+    template<typename ForwardIterator, typename Sentinel, typename T, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<ForwardIterator>
+    find_last(ForwardIterator first, Sentinel last, const T & value, Proj proj = {})
+
+    template<typename R, typename T, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<iterator_t<R>>
+    find_last(R && r, const T & value, Proj proj = {})
+
+These overloads of `find_last` return a subrange `[it, end)`, where `it` is
+the position of the last element that is equal to `x` in the given range, and
+`end` is the end of the given range.
+
+    template<typename ForwardIterator, typename Sentinel, typename Pred, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<ForwardIterator>
+    find_last_if(ForwardIterator first, Sentinel last, Pred pred, Proj proj = {})
+
+    template<typename R, typename Pred, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<iterator_t<R>>
+    find_last_if(R && r, Pred pred, Proj proj = {})
+
+These overloads of `find_if_last` return a subrange `[it, end)`, where `it` is
+the position of the last element for which `pred` returns `true` in the given
+range, and `end` is the end of the given range.
+
+    template<typename ForwardIterator, typename Sentinel, typename Pred, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<ForwardIterator>
+    find_last_if_not(ForwardIterator first, Sentinel last, Pred pred, Proj proj = {})
+
+    template<typename R, typename Pred, typename Proj = identity>
+    BOOST_CXX14_CONSTEXPR subrange<iterator_t<R>>
+    find_last_if_not(R && r, Pred pred, Proj proj = {})
+
+These overloads of `find_if_last` return a subrange `[it, end)`, where `it` is
+the position of the last element for which `pred` returns `false` in the given
+range, and `end` is the end of the given range.
+
+[heading Examples]
+
+Given the container `c1` containing `{ 2, 1, 2 }`, then
+
+    find_last        ( c1.begin(), c1.end(), 2                          ) --> --c1.end()
+    find_last        ( c1.begin(), c1.end(), 3                          ) --> c1.end()
+    find_last_if     ( c1.begin(), c1.end(), [](int i) {return i == 2;} ) --> --c1.end()
+    find_last_if     ( c1.begin(), c1.end(), [](int i) {return i == 3;} ) --> c1.end()
+    find_last_if_not ( c1.begin(), c1.end(), [](int i) {return i == 2;} ) --> std::prev(c1.end(), 2)
+    find_last_if_not ( c1.begin(), c1.end(), [](int i) {return i == 1;} ) --> c1.end()
+
+[heading Iterator Requirements]
+
+All variants work on forward iterators.
+
+[heading Complexity]
+
+Linear.
+
+[heading Exception Safety]
+
+All of the variants take their parameters by value and do not depend upon any
+global state. Therefore, all the routines in this file provide the strong
+exception guarantee.
+
+[heading Notes]
+
+All variants are `constexpr` in C++14 or later.
+
+[endsect]
+
+[/ File find_last.qbk
+Copyright 2022 T. Zachary Laine
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]

include/boost/algorithm/cxx20_helper.hpp

@@ -0,0 +1,92 @@
+/*
+   Copyright (c) T. Zachary Laine 2022.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+#ifndef BOOST_ALGORITHM_CXX20_HELPER_HPP
+#define BOOST_ALGORITHM_CXX20_HELPER_HPP
+
+#include <boost/config.hpp>
+#include <boost/stl_interfaces/view_interface.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <type_traits>
+
+
+namespace boost { namespace algorithm {
+
+    struct identity
+    {
+        template<typename T>
+        BOOST_CXX14_CONSTEXPR T && operator()(T && x) const noexcept
+        {
+            return (T &&) x;
+        }
+    };
+
+#if defined(__cpp_lib_concepts)
+    template<typename R>
+    using iterator_t = std::ranges::iterator_t<R>;
+    template<typename R>
+    using sentinel_t = std::ranges::sentinel_t<R>;
+#else
+    template<typename R>
+    using iterator_t = decltype(boost::begin(std::declval<R>()));
+    template<typename R>
+    using sentinel_t = decltype(boost::end(std::declval<R>()));
+#endif
+
+    template<typename Iterator, typename Sentinel = Iterator>
+    struct subrange
+        : stl_interfaces::view_interface<subrange<Iterator, Sentinel>>
+    {
+        BOOST_CXX14_CONSTEXPR subrange() = default;
+        BOOST_CXX14_CONSTEXPR subrange(Iterator first, Sentinel last) :
+            first_(first), last_(last)
+        {}
+        template<typename R>
+        BOOST_CXX14_CONSTEXPR explicit subrange(const R & r) :
+            first_(boost::begin(r)), last_(boost::end(r))
+        {}
+
+        BOOST_CXX14_CONSTEXPR Iterator begin() const { return first_; }
+        BOOST_CXX14_CONSTEXPR Sentinel end() const { return last_; }
+
+        [[nodiscard]] BOOST_CXX14_CONSTEXPR subrange
+        next(std::ptrdiff_t n = 1) const
+        {
+            return subrange{std::next(first_), last_};
+        }
+        [[nodiscard]] BOOST_CXX14_CONSTEXPR subrange
+        prev(std::ptrdiff_t n = 1) const
+        {
+            return subrange{std::prev(first_), last_};
+        }
+
+        BOOST_CXX14_CONSTEXPR subrange & advance(std::ptrdiff_t n)
+        {
+            std::advance(first_, n);
+            return *this;
+        }
+
+        template<
+            typename Iterator2,
+            typename Sentinel2,
+            typename Enable = std::enable_if_t<
+                std::is_convertible<Iterator, Iterator2>::value &&
+                std::is_convertible<Sentinel, Sentinel2>::value>>
+        BOOST_CXX14_CONSTEXPR operator subrange<Iterator2, Sentinel2>() const
+        {
+            return {first_, last_};
+        }
+
+    private:
+        Iterator first_;
+        Sentinel last_;
+    };
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_CXX20_HELPER