1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___PSTL_BACKEND_FWD_H
10#define _LIBCPP___PSTL_BACKEND_FWD_H
11
12#include <__config>
13
14#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15# pragma GCC system_header
16#endif
17
18_LIBCPP_PUSH_MACROS
19#include <__undef_macros>
20
21//
22// This header declares available PSTL backends and the functions that must be implemented in order for the
23// PSTL algorithms to be provided.
24//
25// Backends often do not implement the full set of functions themselves -- a configuration of the PSTL is
26// usually a set of backends "stacked" together which each implement some algorithms under some execution
27// policies. It is only necessary for the "stack" of backends to implement all algorithms under all execution
28// policies, but a single backend is not required to implement everything on its own.
29//
30// The signatures used by each backend function are documented below.
31//
32// Exception handling
33// ==================
34//
35// PSTL backends are expected to report errors (i.e. failure to allocate) by returning a disengaged `optional` from
36// their implementation. Exceptions shouldn't be used to report an internal failure-to-allocate, since all exceptions
37// are turned into a program termination at the front-end level. When a backend returns a disengaged `optional` to the
38// frontend, the frontend will turn that into a call to `std::__throw_bad_alloc();` to report the internal failure to
39// the user.
40//
41
42#if _LIBCPP_STD_VER >= 17
43
44_LIBCPP_BEGIN_NAMESPACE_STD
45namespace __pstl {
46
47template <class... _Backends>
48struct __backend_configuration;
49
50struct __default_backend_tag;
51struct __libdispatch_backend_tag;
52struct __serial_backend_tag;
53struct __std_thread_backend_tag;
54
55# if defined(_LIBCPP_PSTL_BACKEND_SERIAL)
56using __current_configuration _LIBCPP_NODEBUG = __backend_configuration<__serial_backend_tag, __default_backend_tag>;
57# elif defined(_LIBCPP_PSTL_BACKEND_STD_THREAD)
58using __current_configuration _LIBCPP_NODEBUG =
59 __backend_configuration<__std_thread_backend_tag, __default_backend_tag>;
60# elif defined(_LIBCPP_PSTL_BACKEND_LIBDISPATCH)
61using __current_configuration _LIBCPP_NODEBUG =
62 __backend_configuration<__libdispatch_backend_tag, __default_backend_tag>;
63# else
64
65// ...New vendors can add parallel backends here...
66
67# error "Invalid PSTL backend configuration"
68# endif
69
70template <class _Backend, class _ExecutionPolicy>
71struct __find_if;
72// template <class _Policy, class _ForwardIterator, class _Predicate>
73// optional<_ForwardIterator>
74// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
75
76template <class _Backend, class _ExecutionPolicy>
77struct __find_if_not;
78// template <class _Policy, class _ForwardIterator, class _Predicate>
79// optional<_ForwardIterator>
80// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
81
82template <class _Backend, class _ExecutionPolicy>
83struct __find;
84// template <class _Policy, class _ForwardIterator, class _Tp>
85// optional<_ForwardIterator>
86// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept;
87
88template <class _Backend, class _ExecutionPolicy>
89struct __any_of;
90// template <class _Policy, class _ForwardIterator, class _Predicate>
91// optional<bool>
92// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
93
94template <class _Backend, class _ExecutionPolicy>
95struct __all_of;
96// template <class _Policy, class _ForwardIterator, class _Predicate>
97// optional<bool>
98// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
99
100template <class _Backend, class _ExecutionPolicy>
101struct __none_of;
102// template <class _Policy, class _ForwardIterator, class _Predicate>
103// optional<bool>
104// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
105
106template <class _Backend, class _ExecutionPolicy>
107struct __is_partitioned;
108// template <class _Policy, class _ForwardIterator, class _Predicate>
109// optional<bool>
110// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
111
112template <class _Backend, class _ExecutionPolicy>
113struct __find_first_of;
114// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
115// optional<_ForwardIterator1>
116// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
117// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred) const noexcept;
118
119template <class _Backend, class _ExecutionPolicy>
120struct __find_end;
121// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
122// optional<_ForwardIterator1>
123// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
124// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred) const noexcept;
125
126template <class _Backend, class _ExecutionPolicy>
127struct __for_each;
128// template <class _Policy, class _ForwardIterator, class _Function>
129// optional<__empty>
130// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __func) const noexcept;
131
132template <class _Backend, class _ExecutionPolicy>
133struct __for_each_n;
134// template <class _Policy, class _ForwardIterator, class _Size, class _Function>
135// optional<__empty>
136// operator()(_Policy&&, _ForwardIterator __first, _Size __size, _Function __func) const noexcept;
137
138template <class _Backend, class _ExecutionPolicy>
139struct __fill;
140// template <class _Policy, class _ForwardIterator, class _Tp>
141// optional<__empty>
142// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
143
144template <class _Backend, class _ExecutionPolicy>
145struct __fill_n;
146// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
147// optional<__empty>
148// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Tp const& __value) const noexcept;
149
150template <class _Backend, class _ExecutionPolicy>
151struct __search;
152// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
153// optional<_ForwardIterator1>
154// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
155// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) const noexcept;
156
157template <class _Backend, class _ExecutionPolicy>
158struct __swap_ranges;
159// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
160// optional<_ForwardIterator2>
161// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
162// _ForwardIterator2 __first2) const noexcept;
163
164template <class _Backend, class _ExecutionPolicy>
165struct __replace;
166// template <class _Policy, class _ForwardIterator, class _Tp>
167// optional<__empty>
168// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
169// _Tp const& __old, _Tp const& __new) const noexcept;
170
171template <class _Backend, class _ExecutionPolicy>
172struct __replace_if;
173// template <class _Policy, class _ForwardIterator, class _Predicate, class _Tp>
174// optional<__empty>
175// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
176// _Predicate __pred, _Tp const& __new_value) const noexcept;
177
178template <class _Backend, class _ExecutionPolicy>
179struct __generate;
180// template <class _Policy, class _ForwardIterator, class _Generator>
181// optional<__empty>
182// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) const noexcept;
183
184template <class _Backend, class _ExecutionPolicy>
185struct __generate_n;
186// template <class _Policy, class _ForwardIterator, class _Size, class _Generator>
187// optional<__empty>
188// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Generator __gen) const noexcept;
189
190template <class _Backend, class _ExecutionPolicy>
191struct __reverse;
192// template <class _Policy, class _BidirectionalIterator>
193// optional<__empty>
194// operator()(_Policy&&, _BidirectionalIterator __first, _BidirectionalIterator __last) const noexcept;
195
196template <class _Backend, class _ExecutionPolicy>
197struct __reverse_copy;
198// template <class _Policy, class _BidirectionalIterator, class _ForwardIterator>
199// optional<_ForwardIterator>
200// operator()(_Policy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
201// _ForwardIterator __result) const noexcept;
202
203template <class _Backend, class _ExecutionPolicy>
204struct __merge;
205// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
206// optional<_ForwardOutIterator>
207// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
208// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
209// _ForwardOutIterator __result, _Comp __comp) const noexcept;
210
211template <class _Backend, class _ExecutionPolicy>
212struct __max_element;
213// template <class _Policy, class _ForwardIterator, class _Compare>
214// optional<_ForwardIterator>
215// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
216
217template <class _Backend, class _ExecutionPolicy>
218struct __min_element;
219// template <class _Policy, class _ForwardIterator, class _Compare>
220// optional<_ForwardIterator>
221// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
222
223template <class _Backend, class _ExecutionPolicy>
224struct __minmax_element;
225// template <class _Policy, class _ForwardIterator, class _Compare>
226// optional<pair<_ForwardIterator, _ForwardIterator>>
227// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
228
229template <class _Backend, class _ExecutionPolicy>
230struct __search_n;
231// template <class _Policy, class _ForwardIterator, class _Size, class _T, class _Predicate>
232// optional<_ForwardIterator>
233// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
234// _Size __count, const _T& __value, _Predicate __pred) const noexcept;
235
236template <class _Backend, class _ExecutionPolicy>
237struct __stable_sort;
238// template <class _Policy, class _RandomAccessIterator, class _Comp>
239// optional<__empty>
240// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
241
242template <class _Backend, class _ExecutionPolicy>
243struct __sort;
244// template <class _Policy, class _RandomAccessIterator, class _Comp>
245// optional<__empty>
246// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
247
248template <class _Backend, class _ExecutionPolicy>
249struct __transform;
250// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
251// optional<_ForwardOutIterator>
252// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
253// _ForwardOutIterator __result,
254// _UnaryOperation __op) const noexcept;
255
256template <class _Backend, class _ExecutionPolicy>
257struct __transform_binary;
258// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
259// class _ForwardOutIterator,
260// class _BinaryOperation>
261// optional<_ForwardOutIterator>
262// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
263// _ForwardIterator2 __first2,
264// _ForwardOutIterator __result,
265// _BinaryOperation __op) const noexcept;
266
267template <class _Backend, class _ExecutionPolicy>
268struct __replace_copy_if;
269// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Predicate, class _Tp>
270// optional<__empty>
271// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
272// _ForwardOutIterator __out_it,
273// _Predicate __pred,
274// _Tp const& __new_value) const noexcept;
275
276template <class _Backend, class _ExecutionPolicy>
277struct __replace_copy;
278// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Tp>
279// optional<__empty>
280// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
281// _ForwardOutIterator __out_it,
282// _Tp const& __old_value,
283// _Tp const& __new_value) const noexcept;
284
285template <class _Backend, class _ExecutionPolicy>
286struct __move;
287// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
288// optional<_ForwardOutIterator>
289// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
290// _ForwardOutIterator __out_it) const noexcept;
291
292template <class _Backend, class _ExecutionPolicy>
293struct __copy;
294// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
295// optional<_ForwardOutIterator>
296// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
297// _ForwardOutIterator __out_it) const noexcept;
298
299template <class _Backend, class _ExecutionPolicy>
300struct __copy_n;
301// template <class _Policy, class _ForwardIterator, class _Size, class _ForwardOutIterator>
302// optional<_ForwardOutIterator>
303// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _ForwardOutIterator __out_it) const noexcept;
304
305template <class _Backend, class _ExecutionPolicy>
306struct __rotate_copy;
307// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
308// optional<_ForwardOutIterator>
309// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
310// _ForwardOutIterator __out_it) const noexcept;
311
312template <class _Backend, class _ExecutionPolicy>
313struct __transform_reduce;
314// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
315// optional<_Tp>
316// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
317// _Tp __init,
318// _BinaryOperation __reduce,
319// _UnaryOperation __transform) const noexcept;
320
321template <class _Backend, class _ExecutionPolicy>
322struct __transform_reduce_binary;
323// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
324// class _Tp, class _BinaryOperation1, class _BinaryOperation2>
325// optional<_Tp> operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
326// _ForwardIterator2 __first2,
327// _Tp __init,
328// _BinaryOperation1 __reduce,
329// _BinaryOperation2 __transform) const noexcept;
330
331template <class _Backend, class _ExecutionPolicy>
332struct __count_if;
333// template <class _Policy, class _ForwardIterator, class _Predicate>
334// optional<__iter_diff_t<_ForwardIterator>>
335// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
336
337template <class _Backend, class _ExecutionPolicy>
338struct __count;
339// template <class _Policy, class _ForwardIterator, class _Tp>
340// optional<__iter_diff_t<_ForwardIterator>>
341// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
342
343template <class _Backend, class _ExecutionPolicy>
344struct __equal_3leg;
345// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
346// optional<bool>
347// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
348// _ForwardIterator2 __first2,
349// _Predicate __pred) const noexcept;
350
351template <class _Backend, class _ExecutionPolicy>
352struct __equal;
353// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
354// optional<bool>
355// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
356// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
357// _Predicate __pred) const noexcept;
358
359template <class _Backend, class _ExecutionPolicy>
360struct __reduce;
361// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation>
362// optional<_Tp>
363// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
364// _Tp __init, _BinaryOperation __op) const noexcept;
365
366template <class _Backend, class _ExecutionPolicy>
367struct __is_heap;
368// template <class _Policy, class _RandomAccessIterator, class _Comp>
369// optional<bool>
370// operator()(_Policy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last,
371// _Comp __comp) const noexcept;
372
373template <class _Backend, class _ExecutionPolicy>
374struct __is_heap_until;
375// template <class _Policy, class _RandomAccessIterator, class _Comp>
376// optional<_RandomAccessIterator>
377// operator()(_Policy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last,
378// _Comp __comp) const noexcept;
379
380template <class _Backend, class _ExecutionPolicy>
381struct __is_sorted;
382// template <class _Policy, class _ForwardIterator, class _Comp>
383// optional<bool>
384// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp&& __comp) const noexcept;
385
386template <class _Backend, class _ExecutionPolicy>
387struct __is_sorted_until;
388// template <class _Policy, class _ForwardIterator, class _Comp>
389// optional<_ForwardIterator>
390// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp&& __comp) const noexcept;
391
392template <class _Backend, class _ExecutionPolicy>
393struct __adjacent_difference;
394// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
395// optional<_ForwardIterator2>
396// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
397// _ForwardIterator2 __first2, _BinaryOperation &&__op) const noexcept;
398
399template <class _Backend, class _ExecutionPolicy>
400struct __mismatch;
401// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
402// optional<pair<_ForwardIterator1, _ForwardIterator2>>
403// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
404// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
405// _Comp __comp) const noexcept;
406
407template <class _Backend, class _ExecutionPolicy>
408struct __mismatch_3leg;
409// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
410// optional<pair<_ForwardIterator1, _ForwardIterator2>>
411// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
412// _ForwardIterator2 __first2, _Comp __comp) const noexcept;
413
414template <class _Backend, class _ExecutionPolicy>
415struct __adjacent_find;
416// template <class _Policy, class _ForwardIterator, class _BinaryPredicate>
417// optional<_ForwardIterator>
418// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last,
419// _BinaryPredicate __predicate) const noexcept;
420
421template <class _Backend, class _ExecutionPolicy>
422struct __lexicographical_compare;
423// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
424// optional<bool>
425// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
426// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Comp __comp) const noexcept;
427
428template <class _Backend, class _ExecutionPolicy>
429struct __destroy;
430// template <class _Policy, class _ForwardIterator>
431// optional<__empty>
432// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
433
434template <class _Backend, class _ExecutionPolicy>
435struct __destroy_n;
436// template <class _Policy, class _ForwardIterator, class _Size>
437// optional<__empty>
438// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
439
440template <class _Backend, class _ExecutionPolicy>
441struct __uninitialized_copy;
442// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
443// optional<_ForwardIterator2>
444// operator()(_Policy&& __policy, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) const
445// noexcept;
446
447template <class _Backend, class _ExecutionPolicy>
448struct __uninitialized_copy_n;
449// template <class _Policy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
450// optional<_ForwardIterator2>
451// operator()(_Policy&& __policy, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) const
452// noexcept;
453
454template <class _Backend, class _ExecutionPolicy>
455struct __uninitialized_default_construct;
456// template <class _Policy, class _ForwardIterator>
457// optional<__empty>
458// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
459
460template <class _Backend, class _ExecutionPolicy>
461struct __uninitialized_default_construct_n;
462// template <class _Policy, class _ForwardIterator, class _Size>
463// optional<__empty>
464// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
465
466template <class _Backend, class _ExecutionPolicy>
467struct __uninitialized_move;
468// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
469// optional<_ForwardIterator2>
470// operator()(_Policy&& __policy, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) const
471// noexcept;
472
473template <class _Backend, class _ExecutionPolicy>
474struct __uninitialized_move_n;
475// template <class _Policy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
476// optional<pair<_ForwardIterator1, _ForwardIterator2>>
477// operator()(_Policy&& __policy, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) const
478// noexcept;
479
480template <class _Backend, class _ExecutionPolicy>
481struct __uninitialized_value_construct;
482// template <class _Policy, class _ForwardIterator>
483// optional<__empty>
484// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
485
486template <class _Backend, class _ExecutionPolicy>
487struct __uninitialized_value_construct_n;
488// template <class _Policy, class _ForwardIterator, class _Size>
489// optional<__empty>
490// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
491
492template <class _Backend, class _ExecutionPolicy>
493struct __uninitialized_fill;
494// template <class _Policy, class _ForwardIterator, class _Tp>
495// optional<__empty>
496// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp &__value) const noexcept;
497
498template <class _Backend, class _ExecutionPolicy>
499struct __uninitialized_fill_n;
500// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
501// optional<__empty>
502// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, const _Tp &__value) const noexcept;
503
504} // namespace __pstl
505_LIBCPP_END_NAMESPACE_STD
506
507#endif // _LIBCPP_STD_VER >= 17
508
509_LIBCPP_POP_MACROS
510
511#endif // _LIBCPP___PSTL_BACKEND_FWD_H
512