[oneDPL] Extend and improve the wording about parallel algorithms

source/elements/oneDPL/source/parallel_api.rst

@@ -14,9 +14,6 @@ All those algorithms work with *C++ Standard aligned execution policies* and wit
 oneDPL also provides *parallel range algorithms*: variations of C++20 range-based algorithms
 that take a oneDPL execution policy.
 
-For all parallel algorithms (including ones with ranges) oneDPL implements list-initialization, where applicable,
-as described in `P2248R8`_ proposal that is accepted for C++26.
-
 Additionally, oneDPL provides wrapper functions for `SYCL`_ buffers, special iterators, and
 a set of non-standard parallel algorithms.
 
@@ -31,4 +28,3 @@ a set of non-standard parallel algorithms.
 
 .. _`C++ Standard`: https://isocpp.org/std/the-standard
 .. _`SYCL`: https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html
-.. _`P2248R8`: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html

source/elements/oneDPL/source/parallel_api/algorithms.rst

@@ -6,8 +6,24 @@
 Parallel Algorithms
 -------------------
 
-The parallel algorithms are defined in the ``<oneapi/dpl/algorithm>`` header,
-in ``namespace oneapi::dpl``.
+oneDPL parallel algorithms are function templates analogous to the algorithms with execution policies defined
+in the `C++ Standard`_, 5th and 6th editions (C++17/20), as well as additional non-standard function templates.
+
+oneDPL parallel algorithms reside in ``namespace oneapi::dpl``.
+Standard-aligned algorithms are defined in the ``<oneapi/dpl/algorithm>``, ``<oneapi/dpl/numeric>``,
+and ``<oneapi/dpl/memory>`` header files, aligned with how the `C++ Standard`_ places the respective functions
+into the standard header files.
+
+The parallel algorithms execute according to a oneDPL execution policy supplied as the first argument.
+
+Where applicable, oneDPL supports list initialization of value parameters of the algorithms,
+as in the working draft of the next C++ standard edition (C++26).
+
+Additional Algorithms
++++++++++++++++++++++
+
+In addition to the standard-aligned parallel algorithms, oneDPL provides the following algorithm functions,
+defined in the ``<oneapi/dpl/algorithm>`` header.
 
 .. code:: cpp
 

source/elements/oneDPL/source/parallel_api/parallel_range_api.rst

@@ -8,6 +8,8 @@ Parallel Range Algorithms
 oneDPL provides variations of algorithms that work with ranges defined in the `C++ Standard`_, 6th edition (C++20)
 and newer. These algorithms execute according to a oneDPL execution policy supplied as the first argument,
 similarly to other oneDPL algorithms.
+[*Note*: These algorithms mostly match the semantics of the parallel range algorithms in the working draft
+of the next C++ standard edition (C++26). -- *end note*]
 
 The oneDPL parallel range algorithms rely on the functionality of C++20 and are not available in the code
 compiled for earlier editions of the C++ standard.
@@ -19,7 +21,7 @@ predefined function objects which static function call operators have the requir
 
 The following differences to the standard serial C++ range algorithms apply:
 
-- List initialization of value parameters is enabled, as in the working draft of the next C++ standard edition (C++26).
+- List initialization of value parameters is enabled, as in the C++26 working draft.
 - Parallel range algorithms cannot be used in constant expressions.
 - The oneDPL execution policy parameter is added.
 - Output data sequences are defined as ranges, not iterators.
@@ -40,9 +42,6 @@ The following differences to the standard serial C++ range algorithms apply:
   `P3709R2 <https://isocpp.org/files/papers/P3709R2.html>`_.
 - ``destroy`` is not marked with ``noexcept``.
 
-[*Note*: These oneDPL algorithms mostly match the semantics of the parallel range algorithms in the C++26 working draft.
--- *end note*]
-
 Auxiliary Definitions
 +++++++++++++++++++++
 
@@ -53,12 +52,13 @@ of parallel range algorithms.
 
    // C++20 analogue of std::projected_value_t; exposition only
    template <typename I, typename Proj>
-   using /*projected-value-type*/ = std::remove_cvref_t<std::invoke_result_t<Proj&, std::iter_value_t<I>&>>;
+   using /*projected-value-type*/ =
+       std::remove_cvref_t<std::invoke_result_t<Proj&, std::iter_value_t<I>&>>;
 
   // C++20 analogue of nothrow-random-access-range in the C++26 working draft; exposition only
   // Semantic requirements are listed further below
   template <typename R>
-  concept nothrow-random-access-range =
+  concept /*nothrow-random-access-range*/ =
     std::ranges::random_access_range<R> &&
     std::is_lvalue_reference_v<std::iter_reference_t<std::ranges::iterator_t<R>>> &&
     std::same_as<std::remove_cvref_t<std::iter_reference_t<std::ranges::iterator_t<R>>>,