Introduce forward definitions

[rodgert]

Summary

These are necessary when the standalone PSTL is pulled into the standard
library

[akukanov]

As I understand, this patch adds forward declarations for all internal functions, similarly to "defs" files having declarations for all functions in namespace std. Perhaps the file names should be aligned with the existing files, e.g. glue_algorithm_internal_defs.h etc.

Also the new files are not included anywhere. Will there be a separate patch that uses these files, or they are intended solely for integration into C++ libraries (or even solely libstdc++)? If the latter, perhaps a usage example could be documented somewhere - in the comments or maybe in a separate readme-like file.

include/pstl/internal/parallel_backend_tbb_fwd.h

11

The backend API was supposed to be implementation independent. Maybe there should be no "tbb" in the file name?

47–50

Currently, cancel_execution() is a standalone function in namespace par_backend. Is this mismatch intentional or accidental?

[rodgert]

Ignore this version, Intel changed the definitions of most (all?) of these entry points in the version committed to LLVM, will resubmit after fixing signatures

include/pstl/internal/algorithm_fwd.h

+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define __PSTL_algorithm_fwd_H
+
+#include <type_traits>
+#include <utility>
+
+namespace __pstl
+{
+namespace internal
+{
+
+template <class _ForwardIterator, class _Pred>
+bool
+brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+             /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Pred>
+bool
+brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+             /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Pred, class _IsVector>
+bool pattern_any_of(_ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+                    /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Pred, class _IsVector>
+bool pattern_any_of(_ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+                    /*parallel=*/std::true_type);
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator for_each_n_serial(_ForwardIterator, _Size, _Function);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator for_each_n(_ForwardIterator, _Size, _Function);
+
+template <class _ForwardIterator, class _Function>
+void brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
+                 /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Function>
+void brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+                 /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                   /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                   /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Brick>
+void pattern_walk_brick(_ForwardIterator, _ForwardIterator, _Brick,
+                        /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Brick>
+void pattern_walk_brick(_ForwardIterator, _ForwardIterator, _Brick,
+                        /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Function>
+void brick_it_walk1(_ForwardIterator, _ForwardIterator, _Function,
+                    /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Function>
+void brick_it_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+                    /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_it_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                      /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_it_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                      /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator brick_walk1_n(_ForwardIterator, _Size, _Function,
+                               /*_IsVectorTag=*/std::false_type);
+
+template <class _RandomAccessIterator, class _DifferenceType, class _Function>
+_RandomAccessIterator brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
+                                    /*vectorTag=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Function, class _IsVector>
+_ForwardIterator pattern_walk1_n(_ForwardIterator, _Size, _Function, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
+_RandomAccessIterator pattern_walk1_n(_RandomAccessIterator, _Size, _Function, _IsVector,
+                                      /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Brick>
+_ForwardIterator pattern_walk_brick_n(_ForwardIterator, _Size, _Brick,
+                                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Brick>
+_RandomAccessIterator pattern_walk_brick_n(_RandomAccessIterator, _Size, _Brick,
+                                           /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator brick_it_walk1_n(_ForwardIterator, _Size, _Function,
+                                  /*_IsVectorTag=*/std::false_type);
+
+template <class _RandomAccessIterator, class _DifferenceType, class _Function>
+_RandomAccessIterator brick_it_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
+                                       /*vectorTag=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Function, class _IsVector>
+_ForwardIterator pattern_it_walk1_n(_ForwardIterator, _Size, _Function, _IsVector,
+                                    /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
+_RandomAccessIterator pattern_it_walk1_n(_RandomAccessIterator, _Size, _Function, _IsVector,
+                                         /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                              /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                  /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function, class _IsVector>
+_RandomAccessIterator2 pattern_walk2_n(_RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
+                                       /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Brick>
+_ForwardIterator2 pattern_walk2_brick(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
+                                      /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
+_RandomAccessIterator2 pattern_walk2_brick(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                           _Brick,
+                                           /*parallel=*/std::true_type);
+
+template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
+_RandomAccessIterator2 pattern_walk2_brick_n(_RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
+                                             /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
+_ForwardIterator2 pattern_walk2_brick_n(_ForwardIterator1, _Size, _ForwardIterator2, _Brick,
+                                        /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                                 /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                                 /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                   /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                   /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                   /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function, class _IsVector>
+_RandomAccessIterator2 pattern_it_walk2(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                        _Function, _IsVector,
+                                        /*parallel=*/std::true_type);
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                     /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                     /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
+_ForwardIterator3 brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
+_RandomAccessIterator3 brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                   _RandomAccessIterator3, _Function,
+                                   /*vector=*/std::true_type) noexcept;
+template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function, class _IsVector>
+_ForwardIterator3 pattern_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
+                                _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function,
+          class _IsVector>
+_RandomAccessIterator3 pattern_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                     _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+bool brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
+                 /* IsVector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
+bool brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
+                 /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+bool pattern_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector,
+                   /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
+bool pattern_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector,
+                   /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Predicate>
+_ForwardIterator brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
+                               /*is_vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Predicate>
+_RandomAccessIterator brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
+                                    /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+_ForwardIterator pattern_find_if(_ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+_ForwardIterator pattern_find_if(_ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+                                 /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate,
+                                 /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate,
+                                 /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                   _BinaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                   _BinaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                      _BinaryPredicate,
+                                      /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                      _BinaryPredicate,
+                                      /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                        _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                        _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                               _BinaryPredicate,
+                               /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                               _BinaryPredicate,
+                               /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate, _IsVector,
+                                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
+_ForwardIterator
+brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+               /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
+_ForwardIterator
+brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+               /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+_ForwardIterator
+pattern_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
+                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+_RandomAccessIterator
+pattern_search_n(_RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
+                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _OutputIterator>
+_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+                             /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _OutputIterator>
+_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+                             /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                           /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator>
+_OutputIterator brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+                           /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                           /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator>
+_OutputIterator brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+                           /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
+_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
+_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
+                              /*vector=*/std::true_type) noexcept;
+
+template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
+std::pair<_DifferenceType, _DifferenceType>
+brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate,
+                  /*vector=*/std::false_type) noexcept;
+template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
+std::pair<_DifferenceType, _DifferenceType>
+brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate,
+                  /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+void
+brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
+                   /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+void
+brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict,
+                   /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
+void
+brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*,
+                        /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
+void
+brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
+                        /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
+_OutputIterator pattern_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
+_OutputIterator pattern_copy_if(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
+                                _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                              /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                              /*is_vector=*/std::true_type) noexcept;
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator pattern_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator pattern_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+                                /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
+OutputIterator brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
+                                 /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
+_OutputIterator brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
+                                  /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate, class _IsVector>
+OutputIterator pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector,
+                                   /*parallel=*/std::false_type) noexcept;
+
+template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
+_DifferenceType
+brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
+                  /*vector=*/std::false_type) noexcept;
+
+template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
+_DifferenceType
+brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
+                  /*vector=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, class _IsVector>
+_OutputIterator pattern_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
+                                    _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+_ForwardIterator2 brick_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                    /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+_ForwardIterator2 brick_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                    /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _IsVector>
+_ForwardIterator2 pattern_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _IsVector,
+                                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _IsVector>
+_ForwardIterator2 pattern_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _IsVector,
+                                      /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator>
+void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+                   /*__is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator>
+void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+                   /*__is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _IsVector>
+void pattern_reverse(_BidirectionalIterator, _BidirectionalIterator, _IsVector,
+                     /*is_parallel=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _IsVector>
+void pattern_reverse(_BidirectionalIterator, _BidirectionalIterator, _IsVector,
+                     /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator>
+_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+                                   /*is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator>
+_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+                                   /*is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+                                     /*is_parallel=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+                                     /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator>
+_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+                              /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator>
+_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+                              /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _IsVector>
+_ForwardIterator pattern_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _IsVector>
+_ForwardIterator pattern_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+                                /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+                                  /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+                                  /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
+                                    /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
+                                    /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                          /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                          /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+bool pattern_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                            /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+bool pattern_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                            /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate>
+_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                              /*__is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate>
+_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                              /*__is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
+_BidirectionalIterator pattern_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                                _IsVector,
+                                                /*is_parallelization=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
+_BidirectionalIterator pattern_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                                _IsVector,
+                                                /*is_parallelization=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
+std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
+                                                                   _OutputIterator2, _UnaryPredicate,
+                                                                   /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
+std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
+                                                                   _OutputIterator2, _UnaryPredicate,
+                                                                   /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
+          class _IsVector>
+std::pair<_OutputIterator1, _OutputIterator2> pattern_partition_copy(_ForwardIterator, _ForwardIterator,
+                                                                     _OutputIterator1, _OutputIterator2,
+                                                                     _UnaryPredicate, _IsVector,
+                                                                     /*is_parallelization=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
+          class _IsVector>
+std::pair<_OutputIterator1, _OutputIterator2> pattern_partition_copy(_RandomAccessIterator, _RandomAccessIterator,
+                                                                     _OutputIterator1, _OutputIterator2,
+                                                                     _UnaryPredicate, _IsVector,
+                                                                     /*is_parallelization=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector, class _IsMoveConstructible>
+void pattern_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                  /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                  /*is_parallel=*/std::true_type,
+                  /*is_move_constructible=*/std::true_type);
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                         /*is_parallel=*/std::true_type);
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                          /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                          /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                              _RandomAccessIterator, _Compare,
+                                              /*__is_vector*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                              _RandomAccessIterator, _Compare, /*__is_vector*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                                _RandomAccessIterator, _Compare, _IsVector,
+                                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                                _RandomAccessIterator, _Compare, _IsVector,
+                                                /*is_parallel=*/std::true_type) noexcept;
+template <class _ForwardIterator, class _Predicate>
+typename std::iterator_traits<_ForwardIterator>::difference_type brick_count(_ForwardIterator, _ForwardIterator,
+                                                                             _Predicate,
+                                                                             /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                /* is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    pattern_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                  /* is_parallel */ std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    pattern_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                  /* is_parallel */ std::true_type, _IsVector);
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator
+brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                    /* IsVector = */ std::true_type, bool) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator
+brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                    /* IsVector = */ std::false_type, bool) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator
+pattern_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                      /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
+
+template <class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
+_RandomAccessIterator
+pattern_adjacent_find(_RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
+                      /* is_parallel */ std::true_type, _IsVector, bool);
+
+template <class _RandomAccessIterator, class _Compare>
+void brick_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+                       /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+void brick_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+                       /* __is_vector = */ std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                         /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp>
+void
+brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+           /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp>
+void
+brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+           /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _IsVector>
+void
+pattern_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+             /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _IsVector>
+_ForwardIterator
+pattern_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+             /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _OutputIterator, class _Size, class _Tp>
+_OutputIterator
+brick_fill_n(_OutputIterator, _Size, const _Tp&,
+             /* __is_vector = */ std::true_type) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp>
+_OutputIterator
+brick_fill_n(_OutputIterator, _Size, const _Tp&,
+             /* __is_vector = */ std::false_type) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp, class _IsVector>
+_OutputIterator
+pattern_fill_n(_OutputIterator, _Size, const _Tp&,
+               /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp, class _IsVector>
+_OutputIterator
+pattern_fill_n(_OutputIterator, _Size, const _Tp&,
+               /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _RandomAccessIterator, class _Generator>
+void brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
+                    /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Generator>
+void brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                    /* is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Generator, class _IsVector>
+void pattern_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                      /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Generator, class _IsVector>
+_ForwardIterator pattern_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                                  /*is_parallel=*/std::true_type, _IsVector);
+
+template <class OutputIterator, class Size, class _Generator>
+OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
+                                /* is_vector = */ std::true_type) noexcept;
+
+template <class OutputIterator, class Size, class _Generator>
+OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
+                                /* is_vector = */ std::false_type) noexcept;
+
+template <class OutputIterator, class Size, class _Generator, class _IsVector>
+OutputIterator pattern_generate_n(OutputIterator, Size, _Generator,
+                                  /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class OutputIterator, class Size, class _Generator, class _IsVector>
+OutputIterator pattern_generate_n(OutputIterator, Size, _Generator,
+                                  /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _UnaryPredicate>
+_RandomAccessIterator brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
+                                      /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel*/ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
+                            _Compare,
+                            /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
+                            _Compare,
+                            /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                              _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare,
+          class _IsVector>
+_OutputIterator pattern_merge(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                              _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
+                              /* is_parallel = */ std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare>
+void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+                         /* __is_vector = */ std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare>
+void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+                         /* __is_vector = */ std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare, class _IsVector>
+void pattern_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
+                           /* is_parallel = */ std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare, class _IsVector>
+void pattern_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
+                           /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                    /* _IsVector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                    /* _IsVector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
+                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
+                      /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                _OutputIterator, _Compare,
+                                /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                _OutputIterator, _Compare,
+                                /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                  _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                  _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare,
+                                       /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare,
+                                       /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                         _OutputIterator, _Compare, _IsVector,
+                                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                         _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _OutputIterator, _Compare,
+                                     /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _OutputIterator, _Compare,
+                                     /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator2, _OutputIterator, _Compare,
+                                               /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator2, _OutputIterator, _Compare,
+                                               /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+                                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+                                                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
+                                          /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
+                                          /* __is_vector = */ std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                            /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                            /* is_parallel = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+_ForwardIterator pattern_min_element(_ForwardIterator, _ForwardIterator, _Compare, _IsVector,
+                                     /* is_parallel = */ std::false_type) noexcept;
+
+template <typename _RandomAccessIterator, typename _Compare, typename _IsVector>
+_RandomAccessIterator pattern_min_element(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                          /* is_parallel = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+std::pair<_ForwardIterator, _ForwardIterator> brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+std::pair<_ForwardIterator, _ForwardIterator> brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+std::pair<_ForwardIterator, _ForwardIterator> pattern_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                     _IsVector,
+                                                                     /* is_parallel = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+std::pair<_ForwardIterator, _ForwardIterator> pattern_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                     _IsVector,
+                                                                     /* is_parallel = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+std::pair<_ForwardIterator1, _ForwardIterator2> brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                               _ForwardIterator2, _Predicate,
+                                                               /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+std::pair<_ForwardIterator1, _ForwardIterator2> brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                               _ForwardIterator2, _Predicate,
+                                                               /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
+std::pair<_ForwardIterator1, _ForwardIterator2>
+    pattern_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, _IsVector,
+                     /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, class _IsVector>
+std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
+    pattern_mismatch(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
+                     _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+} // namespace internal
+} // namespace __pstl
+#endif /* __PSTL_algorithm_fwd_H */

include/pstl/internal/numeric_fwd.h

+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define __PSTL_numeric_fwd_H
+
+#include <type_traits>
+#include <utility>
+
+namespace __pstl
+{
+namespace internal
+{
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
+_Tp brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                           _BinaryOperation2,
+                           /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
+_Tp brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                           _BinaryOperation2,
+                           /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2,
+          class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                             _BinaryOperation2, _IsVector,
+                             /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, class _BinaryOperation1,
+          class _BinaryOperation2, class _IsVector>
+_Tp
+pattern_transform_reduce(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Tp, _BinaryOperation1,
+                         _BinaryOperation2, _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
+_Tp brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+                           /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+_Tp brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+                           /*is_vector=*/std::false_type) noexcept;
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
+                             /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
+                             /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
+std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                                                     _UnaryOperation, _Tp, _BinaryOperation,
+                                                     /*Inclusive*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
+std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                                                     _UnaryOperation, _Tp, _BinaryOperation,
+                                                     /*Inclusive*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
+          class _Inclusive, class _IsVector>
+
+_OutputIterator pattern_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp,
+                                       _BinaryOperation, _Inclusive, _IsVector,
+                                       /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
+          class _Inclusive, class _IsVector>
+_OutputIterator pattern_transform_scan(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryOperation,
+                                       _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                          /*is_vector*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                          /*is_vector*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
+_OutputIterator pattern_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                            _IsVector, /*is_parallel*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
+_OutputIterator pattern_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                            _IsVector, /*is_parallel*/ std::true_type) noexcept;
+
+} // namespace internal
+} // namespace __pstl
+#endif /* __PSTL_numeric_fwd_H */

include/pstl/internal/parallel_backend_tbb_fwd.h

+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __PSTL_parallel_backend_tbb_fwd_H
+#define __PSTL_parallel_backend_tbb_fwd_H
+
+namespace __pstl
+{
+namespace par_backend
+{
+
+//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
+template <class _Index, class _Fp>
+void parallel_for(_Index, _Index, _Fp);
+
+template <class _Value, class _Index, typename _RealBody, typename _Reduction>
+_Value
+parallel_reduce(_Index, _Index, const _Value&, const _RealBody&, const _Reduction&);
+
+template <class _Index, class _Up, class _Tp, class _Cp, class _Rp>
+_Tp parallel_transform_reduce(_Index, _Index, _Up, _Cp, _Rp);
+
+template <class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
+_Tp parallel_transform_scan(_Index, _Up, _Tp, _Cp, _Rp, _Sp);
+
+template <typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
+void parallel_strict_scan(_Index, _Tp, _Rp, _Cp, _Sp, _Ap);
+
+template <typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
+void parallel_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _LeafSort);
+
+template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
+          typename _Compare, typename _LeafMerge>
+void parallel_merge(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
+                    _RandomAccessIterator3, _Compare, _LeafMerge);
+
+template <typename _RandomAccessIterator, typename _Compare>
+void parallel_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare);
+
+struct backend_impl_t
+{
+    static cancel_execution();
+};
+
+} // namespace par_backend
+} // namespace __pstl
+
+#endif /* __PSTL_parallel_backend_tbb_fwd_H */