1) The execution policy type used as a unique type to disambiguate parallel algorithm overloading and require that a parallel algorithm's execution may not be parallelized. The invocations of element access functions in parallel algorithms invoked with this policy (usually specified asstd::execution::seq) are indeterminately sequenced in the calling thread.

2) The execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm's execution may be parallelized. The invocations of element access functions in parallel algorithms invoked with this policy (usually specified asstd::execution::par) are permitted to execute in either the invoking thread or in a thread implicitly created by the library to support parallel algorithm execution. Any such invocations executing in the same thread are indeterminately sequenced with respect to each other. If the threads of execution created bystd::thread orstd::jthread provide concurrent forward progress guarantees, then the threads of execution created by the library provide parallel forward progress guarantees. Otherwise, the provided forward progress guarantee is implementation-defined. Note: parallel forward progress guarantees that if a thread of execution makes a step, it will eventually make another step, enabling threads to enter critical sections and take locks, because the thread that has the lock will be eventually scheduled again and be able to release it.

3) The execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm's execution may be parallelized, vectorized, or migrated across threads (such as by a parent-stealing scheduler). The invocations of element access functions in parallel algorithms invoked with this policy are permitted to execute in an unordered fashion in unspecified threads, and unsequenced with respect to one another within each thread. The invocation of element access functions in parallel algorithms invoked with this policy are not permitted to invoke vectorization-unsafe operations, like those specified by the standard library to synchronize, including those ofstd::atomic and other concurrency primitives. If the threads of execution created bystd::thread orstd::jthread provide concurrent forward progress guarantees, then the threads of execution created by the library provide weakly parallel forward progress guarantees. Otherwise, the provided forward progress guarantee is that of the thread invoking the parallel algorithm. Note: weakly parallel forward progress guarantees that one of the threads of execution that have made a step will eventually make another step, which does not allow threads to enter critical sections or take locks, because the thread that has the lock may not be scheduled again until a thread that is attempting to take the lock has exited.

4) The execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm's execution may be vectorized, e.g., executed on a single thread using instructions that operate on multiple data items.

int a[]={0,1};std::vector<int> v;std::for_each(std::execution::par,std::begin(a),std::end(a),[&](int i){    v.push_back(i*2+1);// Error: data race});

std::atomic<int> x{0};int a[]={1,2};std::for_each(std::execution::par,std::begin(a),std::end(a),[&](int){    x.fetch_add(1,std::memory_order_relaxed);while(x.load(std::memory_order_relaxed)==1){}// Error: assumes execution order});

int x=0;std::mutex m;int a[]={1,2};std::for_each(std::execution::par,std::begin(a),std::end(a),[&](int){std::lock_guard<std::mutex> guard(m);++x;// correct});

int x=0;std::mutex m;int a[]={1,2};std::for_each(std::execution::par_unseq,std::begin(a),std::end(a),[&](int){std::lock_guard<std::mutex> guard(m);// Error: lock_guard constructor calls m.lock()++x;});