inplace_vector
A dynamicallyresizable vector with fixed capacity and embedded storage
Document number: P0843R8.
Date: 20230616.
Authors: Gonzalo Brito Gadeschi, Timur Doumler, Nevin Liber, David Sankel <dsankel _at_ adobe.com>.
Reply to: Timur Doumler <papers _at_ timur.audio>.
Audience: LEWG.
Table of Contents
Changelog
 Revision 8 Varna 2023 draft
 Added LEWG poll showing consensus for
<inplace_vector>
header.
 Add feature test macro
 Add
try_push_back
and unchecked_push_back
to wording.
 Add
at
to inplace_vector
class synopsis.
 Add range construction and assignment.
 Add missing
reserve
method that throws bad_alloc
if capacity()
is exceeded.
 Add missing
shrink_to_fit
method that has no effects.
 Add missing
insert_range
.
 Add wording for move constructor semantics (trivial if
T
is trivial).
 Add wording for destructor semantics (trivial if
T
is trivial).
 Remove deduction guidelines since cannot deduce
capacity()
meaningfully.
 Add to containers.sequences.general.
 Add to sequence containers table.
 Add to iterator.range.
 Add to diff.cpp03.library.
 Add poll result confirming unchecked_push_back.
 Add erasure.
 Add poll result confirming the overall design.
 Review synopsis/wording for other missing functions.
 Update
operator==
to operator<=>
using hidden friends for them.
 Made
<inplace_vector>
not freestanding (this will be handled in a separate paper).
 Revision 7 Varna 2023
 Rename
static_vector
to inplace_vector
throughout.
 Update
try_push_back
APIs to return T*
with rationale.
 Update
push_back
to throw std::bad_alloc
with rationale .
 Triviallycopyable if
value_type
is triviallycopyable.
 Request LEWG poll regarding <vector> or <inplace_vector> header.
 Make
push_back
return a reference
 Revision 6: for Varna 2023 following Kona’s 2022 guidance
 Updated push_back semantics to follow std::vector (note about exception to throw).
 Added
try_push_back
returning an optional
 Added
push_back_unchecked
: excedding capacity exhibits undefined behavior.
 Added note about naming.
 Revision 5:
 Update contact wording and contact data.
 Removed naming discussion, since it was resolved (last available in P0843r4).
 Removed future extensions discussion (last available in P0843r4).
 Addressed LEWG feedback regarding movesemantics and exceptionsafety.
 Revision 4:
 LEWG suggested that push_back should be UB when the capacity is exceeded
 LEWG suggested that this should be a freestanding header
 Revision 3:
 Include LWG design questions for LEWG.
 Incorporates LWG feedback.
 Revision 2
 Replace the placeholder name
fixed_capacity_vector
with static_vector
 Remove at checked element access member function.
 Add changelog section.
 Revision 1
 Minor style changes and bugfixes.
Introduction
This paper proposes a modernized boost::static_vector<T, Capacity>
[1]. That is, a dynamicallyresizable vector
with compiletime fixed capacity and contiguous embedded storage in which the elements are stored within the vector object itself.
Its API closely resembles that of std::vector<T, A>
. It is a contiguous container with O(1)
insertion and removal of elements at the end (nonamortized) and worst case O(size())
insertion and removal otherwise. Like std::vector
, the elements are initialized on insertion and destroyed on removal. For trivial value_type
s, the vector is fully usable inside constexpr
functions.
Motivation and Scope
The inplace_vector
container is useful when:
 memory allocation is not possible, e.g., embedded environments without a free store, where only a stack and the static memory segment are available,
 memory allocation imposes an unacceptable performance penalty, e.g., with respect to latency,
 allocation of objects with complex lifetimes in the staticmemory segment is required,
std::array
is not an option, e.g., if nondefault constructible objects must be stored,
 a dynamicallyresizable array is required within
constexpr
functions,
 the storage location of the
inplace_vector
elements is required to be within the inplace_vector
object itself (e.g. to support memcpy
for serialization purposes).
Existing practice
There are at least 3 widely used implementations of inplace_vector
: Boost.Container [1], EASTL [2], and Folly [3]. Boost.Container
implements inplace_vector
as a standalone type with its own guarantees. EASTL and Folly implement it via an extra template parameter in their small_vector
types.
Custom allocators like Howard Hinnant’s stack_alloc
[4] emulate inplace_vector
on top of std::vector
, but as discussed in the next sections, this emulation is not great.
Other prior art includes:
A reference implementation of this proposal is available here (godbolt).
Design
The design described below was approved at LEWG Varna '23:
 POLL: The provided signatures and semantics that D08437R7 provides for push_back, emplace_back, try_push_back, try_emplace_back, and the unchecked versions are acceptable.
Strongly Favor 
Weakly Favor 
Neutral 
Weakly Against 
Strongly Against 
9 
7 
0 
0 
0 
 POLL: We approve the design of D0843R7 (inplace_vector) with the changes already polled.
Strongly Favor 
Weakly Favor 
Neutral 
Weakly Against 
Strongly Against 
11 
5 
0 
0 
0 
Standalone or a special case another type?
The EASTL [2] and Folly [3] special case small_vector
, e.g., using a 4th template parameter, to make it become a inplace_vector
. P0639R0: Changing attack vector of the constexpr_vector
[7] proposes improving the Allocator
concepts to allow implementing inplace_vector
as a special case of vector
with a custom allocator. Both approaches produce specializations of small_vector
or vector
whose methods subtly differ in terms of effects, exceptionsafety, iterator invalidation, and complexity guarantees.
This proposal closely follows boost::container::static_vector<T,Capacity>
[1] and proposes inplace_vector
as a standalone type.
Where possible, this proposal defines the semantics of inplace_vector
to match vector
. Providing the same programming model makes this type easier to teach, use, and makes it easy to “just change” one type on a program to, e.g., perform a performance experiment without accidentally introducing undefined behavior.
Layout
inplace_vector
models ContiguousContainer
. Its elements are stored and properly aligned within the inplace_vector
object itself. If the Capacity
is zero the container has zero size:
static_assert(is_empty_v<inplace_vector<T, 0>>);
The offset of the first element within inplace_vector
is unspecified, and T
s are not allowed to overlap.
The layout differs from vector
, since inplace_vector
does not store the capacity
field (it’s known from the template parameter).
If T
is triviallycopyable or N == 0
, then inplace_vector<T, N>
is also trivially copyable to support HPC (such as copying one between a CPU and a GPU), serialization/deserialization, which is important for use cases like sending a vector via MPI_Send
, etc.
static_assert(!is_trivially_copyable_v<T>  is_trivially_copyable_v<inplace_vector<T, C>>  N == 0);
Move semantics
A movedfrom inplace_vector
is left in a valid but unspecified state (option 3 below) unless T
is triviallycopyable, in which case the size of the inplace_vector
does not change (array
semantics, option 2 below). That is:
inplace_vector a(10);
inplace_vector b(std::move(a));
assert(a.size() == 10);
moves a
’s elements elementwise into b
, and afterwards the size of the movedfrom inplace_vector
may have changed.
This prevents code from relying on the size staying the same (and therefore being incompatible with changing an inplace_vector
type back to vector
) without incuring the cost of having to clear the inplace_vector
.
When T
is triviallycopyable, array
semantics are used to provide trivial move operations.
This is different from LEWG Kona '22 Polls (22 in person + 8 remote) and we’d like to poll on these semantics again:
Alternatives:
vector
semantics: guarantees that inplace_vector
is left empty (this happens with move assignment when using std::allocator<T>
and always with move construction).
 Pro: same programming model as
vector
.
 Pro: increases safety by requiring users to reinitialize vector elements.
 Con: clearing an
inplace_vector
is not free.
 Con:
inplace_vector<T, N>
can no longer be made trivially copyable for a trivially copyable T
, as the move operations can no longer be trivial.
array
semantics: guarantees that size()
of inplace_vector
does not change, and that elements are left in their movedfrom state.
 Pro: no additional runtime cost incurred.
 Con: different programming model than
vector
.
 “valid but unspecified state”
 Con: different programming model than
vector
and array
, requires calling size()
 Pro: code calling
size()
is correct for both vector
and inplace_vector
, enabling changing the type back and forth.
Exception Safety
When using the inplace_vector
APIs, the following types of failures are expected:
 The
value_type
’s constructors/assignment/destructors/swap can potentially throw
(depends on noexcept
),
 Mutating operations exceeding the capacity (
push_back
, insert
, emplace
, inplace_vector(value_type, size)
, inplace_vector(begin, end)
…), and
 Outofbounds unchecked access:
front
/back
/pop_back
when empty, operator[]
.
For inplace_vector
, we choose the same semantics as for vector
:
 When
value_type
’s operations are invoked, inplace_vector
exceptionsafety guarantees depend on whether these operations throw, which is detected with noexcept
if the API has a narrow contract.
 Mutating operations that exceed the capacity ask “allocator embedded within the
inplace_vector
”, which has run out of space, for more memory, and therefore throw std::bad_alloc
like vector
APIs do (e.g. a pmr
“stack allocator” throws std::bad_alloc
as well). This preserves the programming model from vector
. std::bad_alloc
also has the property that it never does an allocation itself.
 Outofbounds unchecked access is a precondition violation.
Alternatives:
 Throw
std::bad_alloc
when the inplace_vector
is outofmemory:
 Pros: same programming model as
vector
.
 Throw “some other exception” when the
inplace_vector
is outofmemory:
 Pros: to be determined.
 Cons: different programming model as
vector
.
 Abort the process
 Pros: portability to embedded platforms without exception support
 Cons: different programming model than
vector
 Precondition violation
 Cons: different proramming model than
vector
, users responsible for checking before modifying vector size, etc.
Fallible APIs
We add the following new fallible APIs which, when the vector size equal its capacity, return nullptr
(do not throw bad_alloc
) without moving from the inputs, enabling them to be reused:
constexpr T* inplace_vector<T, C>::try_push_back(const T& value);
constexpr T* inplace_vector<T, C>::try_push_back(T&& value);
template<class... Args>
constexpr T* try_emplace_back(Args&&... args);
They can be used as follows
T value = T();
if (!v.try_push_back(value)) {
std::cerr << "Failed to insert " << value << std::endl;
std::terminate();
}
Fallible Unchecked APIs
We add the following new fallible unchecked APIs for which exceeding the capacity is a precondition violation:
constexpr T& inplace_vector<T, C>::unchecked_push_back(const T& value);
constexpr T& inplace_vector<T, C>::unchecked_push_back(T&& value);
template<class... Args>
constexpr T& unchecked_emplace_back(Args&&... args);
These APIs were requested in LEWG Kona '22 (22 in person + 8 remote):
This was confirmed at LEWG Varna '23 after a discussion on safety:
 POLL: D0843R7 should remove the unchecked versions of push_back and emplace_back
Strongly Favor 
Weakly Favor 
Neutral 
Weakly Against 
Strongly Against 
1 
5 
3 
3 
7 
The name unchecked_push_back
was polled in LEWG Varna '23:
The potential impact of the three APIs on code size and performance is shown here, where the main difference between try_push_back
and unchecked_push_back
is the presenece of an extra branch in try_push_back
.
Iterator invalidation
inplace_vector
iterator invalidation guarantees differ from std::vector
:
 moving a
inplace_vector
invalidates all iterators, and
 swapping two
inplace_vector
s invalidates all iterators.
inplace_vector
APIs that potentially invalidate iterators are: resize(n)
, resize(n, v)
, pop_back
, erase
, and swap
.
Freestanding
The inplace_vector
APIs are not freestanding because all the insertion APIs (constructors, push back, insert, …) may throw bad_alloc
.
If we were to only make the nonthrowing APIs available in free standing, then this type would be useless in free standing.
We intend to propose making this freestanding in a different paper where we figure out how to do that.
We’d need to add it to: [library.requirements.organization.compliance]
When we fix this we’d need to add <inplace_vector>
to [tab:headers.cpp.fs]:
We propose that this container goes into its own header <inplace_vector>
rather than in header <vector>
.
LWG asked for inplace_vector
to be part of the <vector>
header. LEWG Varna '23 took the following poll:
That is, consensus against change.
Return type of push_back
In C++20, both push_back
and emplace_back
were slated to return a reference
(they used to both return void
). Even with plenary approval, changing push_back
turned out to be an ABI break that was backed out, leaving the situation where emplace_back
returns a reference
but push_back
is still void
. This ABI issue doesn’t apply to new types. Should push_back
return a reference
to be consistent with emplace_back
, or should it be consistent with older containers?
Request LEWG to poll on that.
reserve
and shrink_to_fit
APIs
shrink_to_fit
requests vector
to decrease its capacity
, but this request may be ignored. inplace_vector
may implement it as a nop (and it may be noexcept
).
reserve(n)
requests the vector
to potentially increase its capacity
, failing if the request can’t be satisfied. inplace_vector
may implement it as a nop if n <= capacity()
, throwing bad_alloc
otherwise.
These APIs make it easier and safe for programs to be “more” parametric over “vectorlike” containers (vector
, small_vector
, inplace_vector
), but since they do not do anything useful for inplace_vector
, we may want to fail to compile instead.
Summary of semantic differences with vector
Aspect 
vector 
inplace_vector 
Capacity 
Indefinite 
N 
Move and swap 
O(1), no iterators invalidated 
array semantics: O(size), invalidates all iterators 
Moved from 
left empty (this happens with move assignment when using std::allocator<T> and always with move construction) 
valid but unspecified state except if T is triviallycopyable, in which case array semantics 
Default construction and destruction of trivial types 
O(1) 
O(capacity) 
Is empty when zero capacity? 
No 
Yes 
Triviallycopyable if is_trivially_copyable_v<T> ? 
No 
Yes 
Name
The class template name was confirmed at LEWG Varna '23:
Options 
Votes 
static_vector 
4 
inplace_vector 
14 
fixed_capacity_vector 
5 
Technical specification
EDITORIAL: This enhancement is a pure headeronly addition to the C++ standard library as the <inplace_vector>
header. It belongs in the “Sequence containers” ([sequences]) part of the “Containers library” ([containers]) as “Class template inplace_vector
”.
Add <inplace_vector>
to [tab:headers.cpp].
Modify:
1 In addition to being available via inclusion of the <iterator>
header, the function templates in [iterator.range] are available when any of the following headers are included: <array>
, <deque>
, <forward_list>
, <list>
, <map>
, <regex>
, <set>
, <span>
, <string>
, <string_view>
, <unordered_map>
, <unordered_set>
, <inplace_vector>
, and <vector>
.
Modify:
1 All of the containers defined in [containers] and in [basic.string] except array
and inplace_vector
meet the additional requirements of an allocatoraware container, as described below.
1 The library describes a standard set of requirements for allocators, which are classtype objects that encapsulate the information about an allocation model. This information includes the knowledge of pointer types, the type of their difference, the type of the size of objects in this allocation model, as well as the memory allocation and deallocation primitives for it. All of the string types, containers (except array
and inplace_vector
), string buffers and string streams ([input.output]), and match_results are parameterized in terms of allocators.
Modify [tab:containers.summary]:

Subclause 
Headers 
[sequences] 
Sequence containers 
<array>, <deque>, <forward_list>, <list>, <vector>, <inplace_vector> 
 A type
X
meets the container requirements if the following types, statements, and expressions are wellformed and have the specified semantics.
typename X::value_type
 Result:
T
 Preconditions:
T
is Cpp17Erasable
from X
(see [container.alloc.reqmts], below).
typename X::reference
typename X::const_reference
typename X::iterator
 Result: A type that meets the forward iterator requirements ([forward.iterators]) with value type
T
. The type X::iterator
is convertible to X::const_iterator
.
typename X::const_iterator
 Result: A type that meets the requirements of a constant iterator and those of a forward iterator with value type
T
.
typename X::differcence_type
 Result: A signed integer type, identical to the difference type of
X::iterator
and X::const_iterator
.
typename X::size_type
 Result: An unsigned integer type that can represent any nonnegative value of
X::difference_type
.
X u;
X u = X();
 Postconditions:
u.empty()
 Complexity: Constant.
X u(a);
X u = a;
 Preconditions:
T
is Cpp17CopyInsertable
into X
(see below).
 Postconditions:
u == a
 Complexity: Linear.
X u(rv);
X u = rv;
 Postconditions:
u
is equal to the value that rv
had before this construction.
 Complexity: Linear for array and
inplace_vector
and constant for all other standard containers.
a = rv
 Result:
X&
.
 Effects: All existing elements of
a
are either move assigned to or destroyed.
 Postconditions: If
a
and rv
do not refer to the same object, a
is equal to the value that rv
had before this assignment.
 Complexity: Linear.
a.~X()
 Result:
void
 Effects: Destroys every element of
a
; any memory obtained is deallocated.
 Complexity: Linear.
a.begin()
 Result:
iterator
; const_iterator
for constant a
.
 Returns: An iterator referring to the first element in the container.
 Complexity: Constant.
a.end()
 Result:
iterator
; const_iterator
for constant a
.
 Returns: An iterator which is the pasttheend value for the container.
 Complexity: Constant.
a.cbegin()
 Result:
const_iterator
.
 Returns:
const_cast<X const&>(a).begin()
 Complexity: Constant.
a.cend()
 Result:
const_iterator
.
 Returns:
const_cast<X const&>(a).end()
 Complexity: Constant.
i <=> j
 Result:
strong_ordering
.
 Constraints:
X::iterator
meets the random access iterator requirements.
 Complexity: Constant.
a == b
 Preconditions:
T
meets the Cpp17EqualityComparable
requirements.
 Result: Convertible to
bool
.
 Returns:
equal(a.begin(), a.end(), b.begin(), b.end())
[Note 1: The algorithm equal
is defined in [alg.equal]. — end note]
 Complexity: Constant if
a.size() != b.size()
, linear otherwise.
 Remarks:
==
is an equivalence relation.
a != b
 Effects: Equivalent to
!(a == b)
.
a.swap(b)
 Result:
void
 Effects: Exchanges the contents of
a
and b
.
 Complexity: Linear for array and
inplace_vector
, and constant for all other standard containers.
swap(a, b)
 Effects: Equivalent to
a.swap(b)
.
r = a
 Result:
X&
.
 Postconditions:
r == a
.
 Complexity: Linear.
a.size()
 Result:
size_type
.
 Returns:
distance(a.begin(), a.end())
, i.e. the number of elements in the container.
 Complexity: Constant.
 Remarks: The number of elements is defined by the rules of constructors, inserts, and erases.
a.max_size()
 Result:
size_type
.
 Returns:
distance(begin(), end())
for the largest possible container.
 Complexity: Constant.
a.empty()
 Result: Convertible to
bool
.
 Returns:
a.begin() == a.end()
 Complexity: Constant.
 Remarks: If the container is empty, then
a.empty()
is true.
 In the expressions
i == j
i != j
i < j
i <= j
i >= j
i > j
i <=> j
i  j
where i
and j
denote objects of a container’s iterator type, either or both may be replaced by an object of the container’s const_iterator
type referring to the same element with no change in semantics.
Unless otherwise specified, all containers defined in this Clause obtain memory using an allocator (see [allocator.requirements]).
[Note 2: In particular, containers and iterators do not store references to allocated elements other than through the allocator’s pointer type, i.e., as objects of type P
or pointer_traits<P>::template rebind<unspecified>
, where P
is allocator_traits<allocator_type>::pointer
. — end note]
Copy constructors for these container types obtain an allocator by calling allocator_traits<allocator_type>::select_on_container_copy_construction
on the allocator belonging to the container being copied. Move constructors obtain an allocator by move construction from the allocator belonging to the container being moved. Such move construction of the allocator shall not exit via an exception. All other constructors for these container types take a const allocator_type&
argument.
[Note 3: If an invocation of a constructor uses the default value of an optional allocator argument, then the allocator type must support valueinitialization. — end note]
A copy of this allocator is used for any memory allocation and element construction performed, by these constructors and by all member functions, during the lifetime of each container object or until the allocator is replaced. The allocator may be replaced only via assignment or swap()
. Allocator replacement is performed by copy assignment, move assignment, or swapping of the allocator only if
allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value
,
allocator_traits<allocator_type>::propagate_on_container_move_assignment::value
, or
allocator_traits<allocator_type>::propagate_on_container_swap::value
is true
within the implementation of the corresponding container operation. In all container types defined in this Clause, the member get_allocator()
returns a copy of the allocator used to construct the container or, if that allocator has been replaced, a copy of the most recent replacement.
 The expression
a.swap(b)
, for containers a
and b
of a standard container type other than array
and inplace_vector
, shall exchange the values of a
and b
without invoking any move, copy, or swap operations on the individual container elements. Lvalues of any Compare, Pred, or Hash types belonging to a
and b
shall be swappable and shall be exchanged by calling swap as described in [swappable.requirements]. If allocator_traits<allocator_type>::propagate_on_container_swap::value
is true
, then lvalues of type allocator_type
shall be swappable and the allocators of a
and b
shall also be exchanged by calling swap
as described in [swappable.requirements]. Otherwise, the allocators shall not be swapped, and the behavior is undefined unless a.get_allocator() == b.get_allocator()
. Every iterator referring to an element in one container before the swap shall refer to the same element in the other container after the swap. It is unspecified whether an iterator with value a.end()
before the swap will have value b.end()
after the swap.
Modify:
1 The headers <array>
, <deque>
, <forward_list>
, <list>
, inplace_vector
, and <vector> define class templates that meet the requirements for sequence containers.
Modify:
sequence.reqmts.1 A sequence container organizes a finite set of objects, all of the same type, into a strictly linear arrangement. The library provides fourthe following basic kinds of sequence containers: vector
, inplace_vector
, forward_list
, list
, and deque
. In addition, array
is provided as a sequence container which provides limited sequence operations because it has a fixed number of elements. The library also provides container adaptors that make it easy to construct abstract data types, such as stacks
, queues
, flat_maps
, flat_multimaps
, flat_sets
, or flat_multisets
, out of the basic sequence container kinds (or out of other programdefined sequence containers).
sequence.reqmts.2 [Note 1: The sequence containers offer the programmer different complexity tradeoffs. vector
is appropriate in most circumstances. array
has a fixed size known during translation. inplace_vector
has a fixed capacity known during translation. list
or forward_list
support frequent insertions and deletions from the middle of the sequence. deque
supports efficient insertions and deletions taking place at the beginning or at the end of the sequence. When choosing a container, remember vector
is best; leave a comment to explain if you choose from the rest! — end note]
sequence.reqmts.69 The following operations are provided for some types of sequence containers but not others. An implementation shall implement them so as to take amortized constant time.
a.front()
 Result:
reference
; const_reference
for constant a
.
 Returns:
*a.begin()
 Remarks: Required for
basic_string
, array
, deque
, forward_list
, list
, inplace_vector
, and vector.
a.back()
a.emplace_front(args)
 Result:
reference
 Preconditions:
T
is Cpp17EmplaceConstructible
into X
from args
.
 Effects: Prepends an object of type
T
constructed with `std::forward<Args>(args)…``.
 Returns: `a.front()``.
 Remarks: Required for
deque
, forward_list
, and list
.
a.emplace_back(args)
 Result: reference
 Preconditions:
T
is Cpp17EmplaceConstructible
into X
from args
. For vector
and inplace_vector
, T
is also Cpp17MoveInsertable
into X
.
 Effects: Appends an object of type
T
constructed with std::forward<Args>(args)...
.
 Returns: `a.back()``.
 Remarks: Required for
deque
, list
, inplace_vector
, and vector.
a.push_front(t)
 Result:
void
 Preconditions:
T
is Cpp17CopyInsertable
into X
.
 Effects: Prepends a copy of
t
.
 Remarks: Required for
deque
, forward_list
, and list
.
a.push_front(rv)
 Result:
void
 Preconditions:
T
is Cpp17MoveInsertable
into X
.
 Effects: Prepends a copy of
rv
.
 Remarks: Required for
deque
, forward_list
, and list
.
a.prepend_range(rg)
 Result:
void
 Preconditions:
T
is Cpp17EmplaceConstructible
into X
from *ranges::begin(rg)
.
 Effects: Inserts copies of elements in
rg
before begin()
. Each iterator in the range rg
is dereferenced exactly once. [Note 3: The order of elements in rg
is not reversed. — end note]
 Remarks: Required for
deque
, forward_list
, and list
.
a.push_back(t)
 Result: Reference
 Returns:
a.back()
.
 Preconditions:
T
is Cpp17CopyInsertable
into X
.
 Effects: Appends a copy of
t
.
 Remarks: Required for
basic_string
, deque
, list
, inplace_vector
, and vector.
a.push_back(rv)
 Result: Reference
 Returns:
a.back()
 Preconditions:
T
is Cpp17MoveInsertable
into X
.
 Effects: Appends a copy of
rv
.
 Remarks: Required for
basic_string
, deque
, list
, inplace_vector
, and vector.
a.append_range(rg)
 Result:
void
 Preconditions:
T
is Cpp17EmplaceConstructible
into X
from *ranges::begin(rg)
. For vector
and inplace_vector
, T
is also Cpp17MoveInsertable
into X
.
 Effects: Inserts copies of elements in
rg
before end()
. Each iterator in the range rg
is dereferenced exactly once.
 Remarks: Required for
deque
, list
,inplace_vector
, and vector.
a.pop_front()
 Result:
void
 Preconditions:
a.empty()
is false
.
 Effects: Destroys the first element.
 Remarks: Required for
deque
, forward_list
, and list
.
a.pop_back()
 Result:
void
 Preconditions:
a.empty()
is false
.
 Effects: Destroys the last element.
 Remarks: Required for
basic_string
, deque
, list
,inplace_vector
, and vector.
a[n]
 Result:
reference
; const_reference
for constant a
 Returns:
*(a.begin() + n)
 Remarks: Required for
basic_string
, array
, deque
, inplace_vector
, and vector.
a.at(n)
 Result:
reference
; const_reference
for constant a
 Returns:
*(a.begin() + n)
 Throws:
out_of_range
if n >= a.size()
.
 Remarks: Required for
basic_string
, array
, deque
, inplace_vector
, and vector
.
#include <compare>
#include <initializer_list>
namespace std {
template <typename T, size_t N>
class inplace_vector;
template <typename T, size_t N>
constexpr void swap(inplace_vector<T, N>& x, inplace_vector<T, N>& y)
noexcept(noexcept(x.swap(y)));
template<class T, size_t N, class U>
constexpr typename vector<T, N>::size_type
erase(inplace_vector<T, N>& c, const U& value);
template<class T, size_t N, class Predicate>
constexpr typename inplace_vector<T, N>::size_type
erase_if(inplace_vector<T, N>& c, Predicate pred);
}
 A
inplace_vector
is a contiguous container that supports constant time insert
and erase
operations at the end; insert
and erase
in the middle take linear time. Its capacity is part of its type and its elements are stored within the inplace_vector
object itself such that that if v
is a inplace_vector<T, N>
, then it obeys the identity &v[n] == &v[0] + n
for all 0 <= n <= v.size()
.
 A
inplace_vector
satisfies the container requirements [container.requirements] with the exception of the swap
member function, whose complexity is linear instead of constant. It satisfies the sequence container requirements, including the optional sequence container requirements ([sequence.reqmts]), with the exception of the push_front
, pop_front
, and emplace_front
member functions, which are not provided. It satisfies the reversible container ([container.requirements]) and contiguous container ([container.requirements.general]) requirements. Descriptions are provided here only for operations on inplace_vector
that are not described in one of these tables or for operations where there is additional semantic information.
 Class
inplace_vector
relies on the implicitlydeclared special member functions [class.default.ctor], [class.dtor], and [class.copy.ctor] to conform to the container requirements table in [container.requirements]]. In addition to the requirements specified in the container requirements table, the move constructor and move assignment operator for array require that T
be Cpp17MoveConstructible
or Cpp17MoveAssignable
, respectively.
 The types
iterator
and const_iterator
meet the constexpr iterator
requirements ([iterator.requirements.general])."
template <typename T, size_t N>
class inplace_vector {
public:
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator = implementationdefined;
using const_iterator = implementationdefined;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
constexpr inplace_vector() noexcept;
constexpr explicit inplace_vector(size_type n);
constexpr inplace_vector(size_type n, const T& value);
template <class InputIterator>
constexpr inplace_vector(InputIterator first, InputIterator last);
template <containercompatiblerange<T> R>
constexpr inplace_vector(from_range_t, R&& rg);
constexpr inplace_vector(const inplace_vector&);
constexpr inplace_vector(inplace_vector&&) noexcept(N == 0  is_nothrow_move_constructible_v<T>);
constexpr inplace_vector(initializer_list<T> il);
constexpr ~inplace_vector();
constexpr inplace_vector& operator=(const inplace_vector& other);
constexpr inplace_vector& operator=(inplace_vector&& other) noexcept(N == 0  is_nothrow_move_assignable_v<T>);
template <class InputIterator>
constexpr void assign(InputIterator first, InputIterator last);
template<containercompatiblerange<T> R>
constexpr void assign_range(R&& rg);
constexpr void assign(size_type n, const_reference u);
constexpr void assign(initializer_list<T> il);
constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
constexpr reverse_iterator rbegin() noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr reverse_iterator rend() noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_iterator cbegin() const noexcept;
constexpr const_iterator cend() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
[[nodiscard]] constexpr bool empty() const noexcept;
constexpr size_type size() const noexcept;
static constexpr size_type max_size() noexcept;
static constexpr size_type capacity() noexcept;
constexpr void resize(size_type sz);
constexpr void resize(size_type sz, const T& c);
constexpr void reserve(size_type n);
constexpr void shrink_to_fit();
constexpr reference operator[](size_type n);
constexpr const_reference operator[](size_type n) const;
constexpr const_reference at(size_type n) const;
constexpr reference at(size_type n);
constexpr reference front();
constexpr const_reference front() const;
constexpr reference back();
constexpr const_reference back() const;
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;
template <class... Args> constexpr reference emplace_back(Args&&... args);
constexpr T& push_back(const T& x);
constexpr T& push_back(T&& x);
template<containercompatiblerange<T> R>
constexpr void append_range(R&& rg);
constexpr void pop_back();
template<class... Args>
constexpr T* try_emplace_back(Args&&... args);
constexpr T* try_push_back(const T& value);
constexpr T* try_push_back(T&& value);
template<class... Args>
constexpr T& unchecked_emplace_back(Args&&... args);
constexpr T& unchecked_push_back(const T& value);
constexpr T& unchecked_push_back(T&& value)
template <class... Args>
constexpr iterator emplace(const_iterator position, Args&&... args);
constexpr iterator insert(const_iterator position, const T& x);
constexpr iterator insert(const_iterator position, T&& x);
constexpr iterator insert(const_iterator position, size_type n, const_reference x);
template <class InputIterator>
constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
template<containercompatiblerange<T> R>
constexpr iterator insert_range(const_iterator position, R&& rg);
constexpr iterator insert(const_iterator position, initializer_list<value_type> il);
constexpr iterator erase(const_iterator position);
constexpr iterator erase(const_iterator first, const_iterator last);
constexpr void swap(inplace_vector& x)
noexcept(is_nothrow_swappable_v<value_type> &&
is_nothrow_move_constructible_v<value_type>);
constexpr void clear() noexcept;
constexpr friend bool operator==(const inplace_vector& x, const inplace_vector& y);
constexpr friend synththreewayresult<value_type>
operator<=>(const inplace_vector& x, const inplace_vector& y);
constexpr friend void swap(inplace_vector& x, inplace_vector& y) noexcept(N == 0  is_nothrow_swappable_v<T>)
{ x.swap(y); }
};
If is_trivially_copy_constructible_v<value_type>
then inplace_vector
moveconstructor is trivial.
If is_trivially_destructible_v<value_type>
then inplace_vector
destructor is trivial.
constexpr inplace_vector() noexcept;
 Effects: Constructs an empty
inplace_vector
.
 Complexity: Constant.
constexpr explicit inplace_vector(size_type n);
 Preconditions:
T
is Cpp17CopyInsertable
into *this
.
 Effects: Constructs a
inplace_vector
with n
defaultinserted elements.
 Complexity: Linear in
n
.
constexpr inplace_vector(size_type n, const value_type& value);
 Preconditions:
T
is Cpp17CopyInsertable
into *this
.
 Effects: Constructs a
inplace_vector
with n
copies of value
.
 Complexity: Linear in
n
.
template <class InputIterator>
constexpr inplace_vector(InputIterator first, InputIterator last);
 Effects: Constructs a
inplace_vector
equal to the range [first, last)
.
 Complexity: Makes only N calls to the copy constructor of
T
(where N is the distance between first
and last
).
template <containercompatiblerange<T> R>
constexpr inplace_vector(from_range_t, R&& rg);
 Effects: Constructs a
inplace_vector
object with the elements of the range rg
.
 Complexity: Initializes exactly N elements from the results of dereferencing successive iterators of
rg
, where N is ranges::distance(rg)
.
[containers.sequences.inplace_vector.capacity] Size and capacity
static constexpr size_type capacity() noexcept
static constexpr size_type max_size() noexcept
constexpr void resize(size_type sz);
 Effects: If
sz < size()
, erases the last size()  sz
elements from the sequence. Otherwise, appends sz  size()
defaultconstructed elements.
 Mandates:
is_default_constructible_v<value_type>
is true.
 Preconditions:
sz <= capacity()
is true.
 Complexity: Linear in
sz
.
constexpr void resize(size_type sz, const value_type& c);
 Effects: If
sz < size()
, erases the last size()  sz
elements from the sequence. Otherwise, appends sz  size()
copies of c
.
 Mandates:
is_copy_constructible_v<value_type>
is true.
 Preconditions:
sz <= capacity()
is true.
 Complexity: Linear in
sz
.
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;
 Returns: A pointer such that
[data(), data() + size())
is a valid range. For a nonempty inplace_vector
, data() == addressof(front())
.
 Complexity: Constant time.
constexpr iterator insert(const_iterator position, const value_type& x);
 Effects: Inserts
x
at position
and invalidates all references to elements after position
.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_copy_constructible_v<value_type>
is true.
 Complexity: Linear in
size()
.
 Remarks: If an exception is thrown by
value_type
’s copy constructor and is_nothrow_move_constructible_v<value_type>
is true
there are no effects. Otherwise, if an exception is thrown by value_type
’s copy constructor the effects are unspecified.
constexpr iterator insert(const_iterator position, size_type n, const value_type& x);
 Effects: Inserts
n
copies of x
at position
and invalidates all references to elements after position
.
 Preconditions:
n <= capacity()  size()
is true.
 Mandates:
is_copy_constructible_v<value_type>
is true.
 Complexity: Linear in
size()
and n
.
 Remarks: If an exception is thrown by
value_type
’s copy constructor and is_nothrow_move_constructible_v<value_type>
is true
there are no effects. Otherwise, if an exception is thrown by value_type
’s copy constructor the effects are unspecified.
constexpr iterator insert(const_iterator position, value_type&& x);
 Effects: Inserts
x
at position
and invalidates all references to elements after position
.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_move_constructible_v<value_type>
is true.
 Complexity: Linear in
size()
.
 Remarks: If an exception is thrown by
value_type
’s move constructor the effects are unspecified.
template <typename InputIterator>
constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
 Effects: Inserts elements in range
[first, last)
at position
and invalidates all references to elements after position
.
 Preconditions:
distance(first, last) <= capacity()  size()
is true.
 Mandates:
is_constructible_v<value_type, decltype(*first)>
is true.
 Complexity: Linear in
size()
and distance(first, last)
.
 Remarks: If an exception is thrown by
value_type
constructor from decltype(*first)
and is_nothrow_move_constructible_v<value_type>
is true
there are no effects. Otherwise, if an exception is thrown by value_type
’s constructor from decltype(*first)
the effects are unspecified.
constexpr iterator insert(const_iterator position, initializer_list<value_type> il);
 Effects: Inserts elements of
il
at position
and invalidates all references to elements after position
.
 Preconditions:
il.size() <= capacity()  size()
is true.
 Mandates:
is_copy_constructible_v<T>
is true.
 Complexity: Linear in
size()
and il.size()
.
 Remarks: If an exception is thrown by
value_type
’s copy constructor and is_nothrow_move_constructible_v<T>
is true
there are no effects. Otherwise, if an exception is thrown by value_type
’s copy constructor the effects are unspecified.
template <class... Args>
constexpr iterator emplace(const_iterator position, Args&&... args);
 Effects: Inserts an element constructed from
args...
at position
and invalidates all references to elements after position
.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_constructible_v<T, Args...>
is true.
 Complexity: Linear in
size()
.
 Remarks: If an exception is thrown by
T
’s constructor from args...
and is_nothrow_move_constructible_v<T>
is true
there are no effects. Otherwise, if an exception is thrown by T
’s constructor from args...
the effects are unspecified.
template <class... Args>
constexpr reference emplace_back(Args&&... args);
 Effects: Inserts an element constructed from
args...
at the end.
 Mandates:
is_constructible_v<T, Args...>
is true.
 Returns: A reference to the added element.
 Complexity: Constant.
 Remarks: If an exception is thrown by
T
’s constructor from args...
there are no effects.
 Throws: ‘std::bad_alloc’ if
size() < capacity()
is true.
constexpr reference push_back(const T& x);
 Effects: Inserts a copy of
x
at the end.
 Mandates:
is_copy_constructible_v<T>
is true.
 Returns: A reference to the added element.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s copy constructor there are no effects.
 Throws: ‘std::bad_alloc’ if
size() < capacity()
is true.
constexpr reference push_back(T&& x);
 Effects: Moves
x
to the end.
 Mandates:
is_move_constructible_v<T>
is true.
 Returns: A reference to the added element.
 Complexity: Constant.
 Remarks: If an exception is thrown by
T
’s move constructor there are no effects.
 Throws: ‘std::bad_alloc’ if
size() < capacity()
is true.
template <class... Args>
constexpr pointer try_emplace_back(Args&&... args);
 Effects: If
size() < capacity()
is true, inserts an element constructed from args...
at the end. Otherwise, there are no effect.
 Mandates:
is_constructible_v<value_type, Args...>
is true.
 Returns: If an element has been inserted, returns a pointer to this element, otherwise returns
nullptr
.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s constructor from args...
there are no effects.
constexpr pointer try_push_back(const value_type& x);
 Effects: If
size() < capacity()
is true, inserts a copy of x
at the end.
 Mandates:
is_copy_constructible_v<value_type>
is true.
 Returns: If an element has been inserted, returns a pointer to this element, otherwise returns
nullptr
.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s copy constructor there are no effects.
constexpr pointer try_push_back(value_type&& x);
 Effects: If
size() < capacity()
is true, moves x
to the end.
 Mandates:
is_move_constructible_v<value_type>
is true.
 Returns: If an element has been inserted, returns a pointer to this element, otherwise returns
nullptr
.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s move constructor there are no effects.
template <class... Args>
constexpr reference unchecked_emplace_back(Args&&... args);
 Effects: Inserts an element constructed from
args...
at the end.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_constructible_v<value_type, Args...>
is true.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s constructor from args...
there are no effects.
constexpr reference unchecked_push_back(const value_type& x);
 Effects: Inserts a copy of
x
at the end.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_copy_constructible_v<value_type>
is true.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s copy constructor there are no effects.
constexpr reference unchecked_push_back(value_type&& x);
 Effects: Moves
x
to the end.
 Preconditions:
size() < capacity()
is true.
 Mandates:
is_move_constructible_v<value_type>
is true.
 Complexity: Constant.
 Remarks: If an exception is thrown by
value_type
’s move constructor there are no effects.
constexpr void pop_back();
 Effects: Removes the last element of the container and destroys it.
 Preconditions:
!empty()
is true.
 Complexity: Constant.
constexpr void reserve(size_type n);
 Effects: none.
 Throws:
bad_alloc
if n > capacity()
.
constexpr void shrink_to_fit();
 Effects: none.
 Throws: nothing.
constexpr iterator erase(const_iterator position);
 Effects: Removes the element at
position
, destroys it, and invalidates references to elements after position
.
 Preconditions:
position
in range [begin(), end())
is true.
 Complexity: Linear in
size()
.
 Remarks: If an exception is thrown by
value_type
’s move constructor the effects are unspecified.
constexpr iterator erase(const_iterator first, const_iterator last);
 Effects: Removes the elements in range
[first, last)
, destroying them, and invalidating references to elements after last
.
 Preconditions:
[first, last)
in range [begin(), end())
is true.
 Complexity: Linear in
size()
and distance(first, last)
.
 Remarks: If an exception is thrown by
value_type
’s move constructor the effects are unspecified.
constexpr void swap(inplace_vector& x)
noexcept(is_nothrow_swappable_v<value_type> &&
is_nothrow_move_constructible_v<value_type>);
 Effects: Exchanges the contents of
*this
with x
. All references to the elements of *this
and x
are invalidated.
 Complexity: Linear in
size()
and x.size()
.
 Remarks: Shall not participate in overload resolution unless
is_move_constructible_v<value_type>
is true
and is_swappable_v<value_type>
is true
.
template<class T, size_t N, class U>
constexpr typename inplace_vector<T, N>::size_type
erase(inplace_vector<T, N>& c, const U& value);
auto it = remove(c.begin(), c.end(), value);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
template<class T, size_t, class Predicate>
constexpr typename inplace_vector<T, N>::size_type
erase_if(inplace_vector<T, N>& c, Predicate pred);
auto it = remove_if(c.begin(), c.end(), pred);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
template <typename T, size_t N>
constexpr void swap(inplace_vector<T, N>& x, inplace_vector<T, N>& y)
noexcept(noexcept(x.swap(y)));
 Constraints: This function shall not participate in overload resolution unless
N == 0
or is_swappable_v<T>
is true
.
 Effects: As if by
x.swap(y)
.
 Complexity: Linear in
size()
and x.size()
.
inplace_vector
shall provide support for the special case N == 0
.
In the case that N == 0
, begin() == end() ==
unique value. The return value of data()
is unspecified.
The effect of calling front()
or back()
for zerosized inplace vector is undefined.
Member function swap()
shall have a nonthrowing exception specification.
Add:
#define __cpp_lib_inplace_vector 202306L
Modify:
 2 Affected subclause: [headers]
 Change: New headers.
 Rationale: New functionality.
 Effect on original feature: The following C++ headers are new:
<array>
, <atomic>
, <chrono>
, <codecvt>
, <condition_variable>
, <forward_list>
, <future>
, <initializer_list>
,<inplace_vector>
, <mutex>
, <random>
, <ratio>
, <regex>
, <scoped_allocator>
, <system_error>
, <thread>
, <tuple>
, <typeindex>
, <type_traits>
, <unordered_map>
, and <unordered_set>
. In addition the following C compatibility headers are new: <cfenv>
, <cinttypes>
, <cstdint>
, and <cuchar>
. Valid C++ 2003 code that #includes
headers with these names may be invalid in this revision of C++.
Acknowledgments
This proposal is based on Boost.Container’s boost::container::static_vector
, mainly authored by Adam Wulkiewicz, Andrew Hundt, and Ion Gaztanaga. The reference implementation is based on Howard Hinnant std::vector
implementation in libc++ and its testsuite. The following people provided valuable feedback that influenced some aspects of this proposal: Walter Brown, Zach Laine, Rein Halbersma, Andrzej Krzemieński, Casey Carter and many others.
inplace_vector
Document number: P0843R8.
Date: 20230616.
Authors: Gonzalo Brito Gadeschi, Timur Doumler, Nevin Liber, David Sankel <dsankel _at_ adobe.com>.
Reply to: Timur Doumler <papers _at_ timur.audio>.
Audience: LEWG.
Table of Contents
Changelog
<inplace_vector>
header.try_push_back
andunchecked_push_back
to wording.at
toinplace_vector
class synopsis.reserve
method that throwsbad_alloc
ifcapacity()
is exceeded.shrink_to_fit
method that has no effects.insert_range
.T
is trivial).T
is trivial).capacity()
meaningfully.operator==
tooperator<=>
using hidden friends for them.<inplace_vector>
not freestanding (this will be handled in a separate paper).static_vector
toinplace_vector
throughout.try_push_back
APIs to returnT*
with rationale.push_back
to throwstd::bad_alloc
with rationale .value_type
is triviallycopyable.push_back
return a referencetry_push_back
returning anoptional
push_back_unchecked
: excedding capacity exhibits undefined behavior.fixed_capacity_vector
withstatic_vector
Introduction
This paper proposes a modernized
boost::static_vector<T, Capacity>
[1]. That is, a dynamicallyresizablevector
with compiletime fixed capacity and contiguous embedded storage in which the elements are stored within the vector object itself.Its API closely resembles that of
std::vector<T, A>
. It is a contiguous container withO(1)
insertion and removal of elements at the end (nonamortized) and worst caseO(size())
insertion and removal otherwise. Likestd::vector
, the elements are initialized on insertion and destroyed on removal. For trivialvalue_type
s, the vector is fully usable insideconstexpr
functions.Motivation and Scope
The
inplace_vector
container is useful when:std::array
is not an option, e.g., if nondefault constructible objects must be stored,constexpr
functions,inplace_vector
elements is required to be within theinplace_vector
object itself (e.g. to supportmemcpy
for serialization purposes).Existing practice
There are at least 3 widely used implementations of
inplace_vector
: Boost.Container [1], EASTL [2], and Folly [3].Boost.Container
implementsinplace_vector
as a standalone type with its own guarantees. EASTL and Folly implement it via an extra template parameter in theirsmall_vector
types.Custom allocators like Howard Hinnant’s
stack_alloc
[4] emulateinplace_vector
on top ofstd::vector
, but as discussed in the next sections, this emulation is not great.Other prior art includes:
contiguous_container
proposal [5]: proposes aStorage
concept.std::constexpr_vector<T>
[6]: proposes a vector that can only be used in constexpr contexts.A reference implementation of this proposal is available here (godbolt).
Design
The design described below was approved at LEWG Varna '23:
Standalone or a special case another type?
The EASTL [2] and Folly [3] special case
small_vector
, e.g., using a 4th template parameter, to make it become ainplace_vector
. P0639R0: Changing attack vector of theconstexpr_vector
[7] proposes improving theAllocator
concepts to allow implementinginplace_vector
as a special case ofvector
with a custom allocator. Both approaches produce specializations ofsmall_vector
orvector
whose methods subtly differ in terms of effects, exceptionsafety, iterator invalidation, and complexity guarantees.This proposal closely follows
boost::container::static_vector<T,Capacity>
[1] and proposesinplace_vector
as a standalone type.Where possible, this proposal defines the semantics of
inplace_vector
to matchvector
. Providing the same programming model makes this type easier to teach, use, and makes it easy to “just change” one type on a program to, e.g., perform a performance experiment without accidentally introducing undefined behavior.Layout
inplace_vector
modelsContiguousContainer
. Its elements are stored and properly aligned within theinplace_vector
object itself. If theCapacity
is zero the container has zero size:The offset of the first element within
inplace_vector
is unspecified, andT
s are not allowed to overlap.The layout differs from
vector
, sinceinplace_vector
does not store thecapacity
field (it’s known from the template parameter).If
T
is triviallycopyable orN == 0
, theninplace_vector<T, N>
is also trivially copyable to support HPC (such as copying one between a CPU and a GPU), serialization/deserialization, which is important for use cases like sending a vector viaMPI_Send
, etc.Move semantics
A movedfrom
inplace_vector
is left in a valid but unspecified state (option 3 below) unlessT
is triviallycopyable, in which case the size of theinplace_vector
does not change (array
semantics, option 2 below). That is:moves
a
’s elements elementwise intob
, and afterwards the size of the movedfrominplace_vector
may have changed.This prevents code from relying on the size staying the same (and therefore being incompatible with changing an
inplace_vector
type back tovector
) without incuring the cost of having to clear theinplace_vector
.When
T
is triviallycopyable,array
semantics are used to provide trivial move operations.This is different from LEWG Kona '22 Polls (22 in person + 8 remote) and we’d like to poll on these semantics again:
POLL: Moving a static_vector should empty it (vector semantics).
POLL: Moving a static_vector should leave it in a valid but unspecified state.
Alternatives:
vector
semantics: guarantees thatinplace_vector
is left empty (this happens with move assignment when usingstd::allocator<T>
and always with move construction).vector
.inplace_vector
is not free.inplace_vector<T, N>
can no longer be made trivially copyable for a trivially copyableT
, as the move operations can no longer be trivial.array
semantics: guarantees thatsize()
ofinplace_vector
does not change, and that elements are left in their movedfrom state.vector
.vector
andarray
, requires callingsize()
size()
is correct for bothvector
andinplace_vector
, enabling changing the type back and forth.Exception Safety
When using the
inplace_vector
APIs, the following types of failures are expected:value_type
’s constructors/assignment/destructors/swap can potentiallythrow
(depends onnoexcept
),push_back
,insert
,emplace
,inplace_vector(value_type, size)
,inplace_vector(begin, end)
…), andfront
/back
/pop_back
when empty,operator[]
.For
inplace_vector
, we choose the same semantics as forvector
:value_type
’s operations are invoked,inplace_vector
exceptionsafety guarantees depend on whether these operations throw, which is detected withnoexcept
if the API has a narrow contract.inplace_vector
”, which has run out of space, for more memory, and therefore throwstd::bad_alloc
likevector
APIs do (e.g. apmr
“stack allocator” throwsstd::bad_alloc
as well). This preserves the programming model fromvector
.std::bad_alloc
also has the property that it never does an allocation itself.Alternatives:
std::bad_alloc
when theinplace_vector
is outofmemory:vector
.inplace_vector
is outofmemory:vector
.vector
vector
, users responsible for checking before modifying vector size, etc.Fallible APIs
We add the following new fallible APIs which, when the vector size equal its capacity, return
nullptr
(do not throwbad_alloc
) without moving from the inputs, enabling them to be reused:They can be used as follows
Fallible Unchecked APIs
We add the following new fallible unchecked APIs for which exceeding the capacity is a precondition violation:
These APIs were requested in LEWG Kona '22 (22 in person + 8 remote):
POLL: If static_vector has unchecked operations (e.g.
push_back_unchecked
), it is okay for checked operations (e.g.push_back
) to throw when they run out of space.This was confirmed at LEWG Varna '23 after a discussion on safety:
The name
unchecked_push_back
was polled in LEWG Varna '23:POLL: (vote for all the options you find acceptable, vote as many times as you like) Feature naming
The potential impact of the three APIs on code size and performance is shown here, where the main difference between
try_push_back
andunchecked_push_back
is the presenece of an extra branch intry_push_back
.Iterator invalidation
inplace_vector
iterator invalidation guarantees differ fromstd::vector
:inplace_vector
invalidates all iterators, andinplace_vector
s invalidates all iterators.inplace_vector
APIs that potentially invalidate iterators are:resize(n)
,resize(n, v)
,pop_back
,erase
, andswap
.Freestanding
The
inplace_vector
APIs are not freestanding because all the insertion APIs (constructors, push back, insert, …) may throwbad_alloc
.If we were to only make the nonthrowing APIs available in free standing, then this type would be useless in free standing.
We intend to propose making this freestanding in a different paper where we figure out how to do that.
We’d need to add it to: [library.requirements.organization.compliance]
When we fix this we’d need to add
<inplace_vector>
to [tab:headers.cpp.fs]:<inplace_vector>
Which header does it belong to?
We propose that this container goes into its own header
<inplace_vector>
rather than in header<vector>
.LWG asked for
inplace_vector
to be part of the<vector>
header. LEWG Varna '23 took the following poll:POLL: D0843R7 should provide
inplace_vector
in<vector>
rather than the proposal’s decision on<inplace_vector>
That is, consensus against change.
Return type of push_back
In C++20, both
push_back
andemplace_back
were slated to return areference
(they used to both returnvoid
). Even with plenary approval, changingpush_back
turned out to be an ABI break that was backed out, leaving the situation whereemplace_back
returns areference
butpush_back
is stillvoid
. This ABI issue doesn’t apply to new types. Shouldpush_back
return areference
to be consistent withemplace_back
, or should it be consistent with older containers?Request LEWG to poll on that.
reserve
andshrink_to_fit
APIsshrink_to_fit
requestsvector
to decrease itscapacity
, but this request may be ignored.inplace_vector
may implement it as a nop (and it may benoexcept
).reserve(n)
requests thevector
to potentially increase itscapacity
, failing if the request can’t be satisfied.inplace_vector
may implement it as a nop ifn <= capacity()
, throwingbad_alloc
otherwise.These APIs make it easier and safe for programs to be “more” parametric over “vectorlike” containers (
vector
,small_vector
,inplace_vector
), but since they do not do anything useful forinplace_vector
, we may want to fail to compile instead.Summary of semantic differences with
vector
vector
inplace_vector
N
array
semantics: O(size), invalidates all iteratorsT
is triviallycopyable, in which casearray
semanticsis_trivially_copyable_v<T>
?Name
The class template name was confirmed at LEWG Varna '23:
Technical specification
EDITORIAL: This enhancement is a pure headeronly addition to the C++ standard library as the
<inplace_vector>
header. It belongs in the “Sequence containers” ([sequences]) part of the “Containers library” ([containers]) as “Class templateinplace_vector
”.[library.requirements.organization.headers]
Add
<inplace_vector>
to [tab:headers.cpp].[iterator.range] Range access
Modify:
1 In addition to being available via inclusion of the
<iterator>
header, the function templates in [iterator.range] are available when any of the following headers are included:<array>
,<deque>
,<forward_list>
,<list>
,<map>
,<regex>
,<set>
,<span>
,<string>
,<string_view>
,<unordered_map>
,<unordered_set>
,<inplace_vector>
, and<vector>
.[container.alloc.reqmts]
Modify:
1 All of the containers defined in [containers] and in [basic.string] except
array
andinplace_vector
meet the additional requirements of an allocatoraware container, as described below.[allocator.requirements.general]
1 The library describes a standard set of requirements for allocators, which are classtype objects that encapsulate the information about an allocation model. This information includes the knowledge of pointer types, the type of their difference, the type of the size of objects in this allocation model, as well as the memory allocation and deallocation primitives for it. All of the string types, containers (except
array
andinplace_vector
), string buffers and string streams ([input.output]), and match_results are parameterized in terms of allocators.[containers.general]
Modify [tab:containers.summary]:
, <inplace_vector>
[container.reqmts] General container requirements
X
meets the container requirements if the following types, statements, and expressions are wellformed and have the specified semantics.T
T
isCpp17Erasable
fromX
(see [container.alloc.reqmts], below).T&
const T&
T
. The typeX::iterator
is convertible toX::const_iterator
.T
.X::iterator
andX::const_iterator
.X::difference_type
.u.empty()
T
isCpp17CopyInsertable
intoX
(see below).u == a
u
is equal to the value thatrv
had before this construction.inplace_vector
and constant for all other standard containers.X&
.a
are either move assigned to or destroyed.a
andrv
do not refer to the same object,a
is equal to the value thatrv
had before this assignment.void
a
; any memory obtained is deallocated.iterator
;const_iterator
for constanta
.iterator
;const_iterator
for constanta
.const_iterator
.const_cast<X const&>(a).begin()
const_iterator
.const_cast<X const&>(a).end()
strong_ordering
.X::iterator
meets the random access iterator requirements.T
meets theCpp17EqualityComparable
requirements.bool
.equal(a.begin(), a.end(), b.begin(), b.end())
[Note 1: The algorithmequal
is defined in [alg.equal]. — end note]a.size() != b.size()
, linear otherwise.==
is an equivalence relation.!(a == b)
.void
a
andb
.inplace_vector
, and constant for all other standard containers.a.swap(b)
.X&
.r == a
.size_type
.distance(a.begin(), a.end())
, i.e. the number of elements in the container.size_type
.distance(begin(), end())
for the largest possible container.bool
.a.begin() == a.end()
a.empty()
is true.where
i
andj
denote objects of a container’s iterator type, either or both may be replaced by an object of the container’sconst_iterator
type referring to the same element with no change in semantics.Unless otherwise specified, all containers defined in this Clause obtain memory using an allocator (see [allocator.requirements]).
[Note 2: In particular, containers and iterators do not store references to allocated elements other than through the allocator’s pointer type, i.e., as objects of type
P
orpointer_traits<P>::template rebind<unspecified>
, whereP
isallocator_traits<allocator_type>::pointer
. — end note]Copy constructors for these container types obtain an allocator by calling
allocator_traits<allocator_type>::select_on_container_copy_construction
on the allocator belonging to the container being copied. Move constructors obtain an allocator by move construction from the allocator belonging to the container being moved. Such move construction of the allocator shall not exit via an exception. All other constructors for these container types take aconst allocator_type&
argument.[Note 3: If an invocation of a constructor uses the default value of an optional allocator argument, then the allocator type must support valueinitialization. — end note]
A copy of this allocator is used for any memory allocation and element construction performed, by these constructors and by all member functions, during the lifetime of each container object or until the allocator is replaced. The allocator may be replaced only via assignment or
swap()
. Allocator replacement is performed by copy assignment, move assignment, or swapping of the allocator only ifallocator_traits<allocator_type>::propagate_on_container_copy_assignment::value
,allocator_traits<allocator_type>::propagate_on_container_move_assignment::value
, orallocator_traits<allocator_type>::propagate_on_container_swap::value
is
true
within the implementation of the corresponding container operation. In all container types defined in this Clause, the memberget_allocator()
returns a copy of the allocator used to construct the container or, if that allocator has been replaced, a copy of the most recent replacement.a.swap(b)
, for containersa
andb
of a standard container type other thanarray
andinplace_vector
, shall exchange the values ofa
andb
without invoking any move, copy, or swap operations on the individual container elements. Lvalues of any Compare, Pred, or Hash types belonging toa
andb
shall be swappable and shall be exchanged by calling swap as described in [swappable.requirements]. Ifallocator_traits<allocator_type>::propagate_on_container_swap::value
istrue
, then lvalues of typeallocator_type
shall be swappable and the allocators ofa
andb
shall also be exchanged by callingswap
as described in [swappable.requirements]. Otherwise, the allocators shall not be swapped, and the behavior is undefined unlessa.get_allocator() == b.get_allocator()
. Every iterator referring to an element in one container before the swap shall refer to the same element in the other container after the swap. It is unspecified whether an iterator with valuea.end()
before the swap will have valueb.end()
after the swap.[containers.sequences.general]
Modify:
1 The headers
<array>
,<deque>
,<forward_list>
,<list>
,inplace_vector
, and <vector> define class templates that meet the requirements for sequence containers.[container.requirements.sequence.reqmts]
Modify:
sequence.reqmts.1 A sequence container organizes a finite set of objects, all of the same type, into a strictly linear arrangement. The library provides
fourthe following basic kinds of sequence containers:vector
,inplace_vector
,forward_list
,list
, anddeque
. In addition,array
is provided as a sequence container which provides limited sequence operations because it has a fixed number of elements. The library also provides container adaptors that make it easy to construct abstract data types, such asstacks
,queues
,flat_maps
,flat_multimaps
,flat_sets
, orflat_multisets
, out of the basic sequence container kinds (or out of other programdefined sequence containers).sequence.reqmts.2 [Note 1: The sequence containers offer the programmer different complexity tradeoffs.
vector
is appropriate in most circumstances.array
has a fixed size known during translation.inplace_vector
has a fixed capacity known during translation.list
orforward_list
support frequent insertions and deletions from the middle of the sequence.deque
supports efficient insertions and deletions taking place at the beginning or at the end of the sequence. When choosing a container, remembervector
is best; leave a comment to explain if you choose from the rest! — end note]sequence.reqmts.69 The following operations are provided for some types of sequence containers but not others. An implementation shall implement them so as to take amortized constant time.
reference
;const_reference
for constanta
.*a.begin()
basic_string
,array
,deque
,forward_list
,list
,inplace_vector
, and vector.reference
;const_reference
for constanta
.basic_string
,array
,deque
,list
,inplace_vector
, and vector.reference
T
isCpp17EmplaceConstructible
intoX
fromargs
.T
constructed with `std::forward<Args>(args)…``.deque
,forward_list
, andlist
.T
isCpp17EmplaceConstructible
intoX
fromargs
. Forvector
andinplace_vector
,T
is alsoCpp17MoveInsertable
intoX
.T
constructed withstd::forward<Args>(args)...
.deque
,list
,inplace_vector
, and vector.void
T
isCpp17CopyInsertable
intoX
.t
.deque
,forward_list
, andlist
.void
T
isCpp17MoveInsertable
intoX
.rv
.deque
,forward_list
, andlist
.void
T
isCpp17EmplaceConstructible
intoX
from*ranges::begin(rg)
.rg
beforebegin()
. Each iterator in the rangerg
is dereferenced exactly once. [Note 3: The order of elements inrg
is not reversed. — end note]deque
,forward_list
, andlist
.a.back()
.T
isCpp17CopyInsertable
intoX
.t
.basic_string
,deque
,list
,inplace_vector
, and vector.a.back()
T
isCpp17MoveInsertable
intoX
.rv
.basic_string
,deque
,list
,inplace_vector
, and vector.void
T
isCpp17EmplaceConstructible
intoX
from*ranges::begin(rg)
. Forvector
andinplace_vector
,T
is alsoCpp17MoveInsertable
intoX
.rg
beforeend()
. Each iterator in the rangerg
is dereferenced exactly once.deque
,list
,inplace_vector
, and vector.void
a.empty()
isfalse
.deque
,forward_list
, andlist
.void
a.empty()
isfalse
.basic_string
,deque
,list
,inplace_vector
, and vector.reference
;const_reference
for constanta
*(a.begin() + n)
basic_string
,array
,deque
,inplace_vector
, and vector.reference
;const_reference
for constanta
*(a.begin() + n)
out_of_range
ifn >= a.size()
.basic_string
,array
,deque
,inplace_vector
, andvector
.[containers.sequences.inplace_vector.syn] Header
<inplace_vector>
synopsis[containers.sequences.inplace_vector] Class template
inplace_vector
[containers.sequences.inplace_vector.overview] Overview
inplace_vector
is a contiguous container that supports constant timeinsert
anderase
operations at the end;insert
anderase
in the middle take linear time. Its capacity is part of its type and its elements are stored within theinplace_vector
object itself such that that ifv
is ainplace_vector<T, N>
, then it obeys the identity&v[n] == &v[0] + n
for all0 <= n <= v.size()
.inplace_vector
satisfies the container requirements [container.requirements] with the exception of theswap
member function, whose complexity is linear instead of constant. It satisfies the sequence container requirements, including the optional sequence container requirements ([sequence.reqmts]), with the exception of thepush_front
,pop_front
, andemplace_front
member functions, which are not provided. It satisfies the reversible container ([container.requirements]) and contiguous container ([container.requirements.general]) requirements. Descriptions are provided here only for operations oninplace_vector
that are not described in one of these tables or for operations where there is additional semantic information.inplace_vector
relies on the implicitlydeclared special member functions [class.default.ctor], [class.dtor], and [class.copy.ctor] to conform to the container requirements table in [container.requirements]]. In addition to the requirements specified in the container requirements table, the move constructor and move assignment operator for array require thatT
beCpp17MoveConstructible
orCpp17MoveAssignable
, respectively.iterator
andconst_iterator
meet the constexpr iteratorrequirements ([iterator.requirements.general])."
[containers.sequences.inplace_vector.cons] Constructors
If
is_trivially_copy_constructible_v<value_type>
theninplace_vector
moveconstructor is trivial.If
is_trivially_destructible_v<value_type>
theninplace_vector
destructor is trivial.constexpr inplace_vector() noexcept;
inplace_vector
.constexpr explicit inplace_vector(size_type n);
T
isCpp17CopyInsertable
into*this
.inplace_vector
withn
defaultinserted elements.n
.constexpr inplace_vector(size_type n, const value_type& value);
T
isCpp17CopyInsertable
into*this
.inplace_vector
withn
copies ofvalue
.n
.template <class InputIterator> constexpr inplace_vector(InputIterator first, InputIterator last);
inplace_vector
equal to the range[first, last)
.T
(where N is the distance betweenfirst
andlast
).template <containercompatiblerange<T> R> constexpr inplace_vector(from_range_t, R&& rg);
inplace_vector
object with the elements of the rangerg
.rg
, where N isranges::distance(rg)
.[containers.sequences.inplace_vector.capacity] Size and capacity
static constexpr size_type capacity() noexcept static constexpr size_type max_size() noexcept
N
.constexpr void resize(size_type sz);
sz < size()
, erases the lastsize()  sz
elements from the sequence. Otherwise, appendssz  size()
defaultconstructed elements.is_default_constructible_v<value_type>
is true.sz <= capacity()
is true.sz
.constexpr void resize(size_type sz, const value_type& c);
sz < size()
, erases the lastsize()  sz
elements from the sequence. Otherwise, appendssz  size()
copies ofc
.is_copy_constructible_v<value_type>
is true.sz <= capacity()
is true.sz
.[containers.sequences.inplace_vector.data] Data
constexpr T* data() noexcept; constexpr const T* data() const noexcept;
[data(), data() + size())
is a valid range. For a nonemptyinplace_vector
,data() == addressof(front())
.[containers.sequences.inplace_vector.modifiers] Modifiers
constexpr iterator insert(const_iterator position, const value_type& x);
x
atposition
and invalidates all references to elements afterposition
.size() < capacity()
is true.is_copy_constructible_v<value_type>
is true.size()
.value_type
’s copy constructor andis_nothrow_move_constructible_v<value_type>
istrue
there are no effects. Otherwise, if an exception is thrown byvalue_type
’s copy constructor the effects are unspecified.constexpr iterator insert(const_iterator position, size_type n, const value_type& x);
n
copies ofx
atposition
and invalidates all references to elements afterposition
.n <= capacity()  size()
is true.is_copy_constructible_v<value_type>
is true.size()
andn
.value_type
’s copy constructor andis_nothrow_move_constructible_v<value_type>
istrue
there are no effects. Otherwise, if an exception is thrown byvalue_type
’s copy constructor the effects are unspecified.constexpr iterator insert(const_iterator position, value_type&& x);
x
atposition
and invalidates all references to elements afterposition
.size() < capacity()
is true.is_move_constructible_v<value_type>
is true.size()
.value_type
’s move constructor the effects are unspecified.template <typename InputIterator> constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
[first, last)
atposition
and invalidates all references to elements afterposition
.distance(first, last) <= capacity()  size()
is true.is_constructible_v<value_type, decltype(*first)>
is true.size()
anddistance(first, last)
.value_type
constructor fromdecltype(*first)
andis_nothrow_move_constructible_v<value_type>
istrue
there are no effects. Otherwise, if an exception is thrown byvalue_type
’s constructor fromdecltype(*first)
the effects are unspecified.constexpr iterator insert(const_iterator position, initializer_list<value_type> il);
il
atposition
and invalidates all references to elements afterposition
.il.size() <= capacity()  size()
is true.is_copy_constructible_v<T>
is true.size()
andil.size()
.value_type
’s copy constructor andis_nothrow_move_constructible_v<T>
istrue
there are no effects. Otherwise, if an exception is thrown byvalue_type
’s copy constructor the effects are unspecified.template <class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
args...
atposition
and invalidates all references to elements afterposition
.size() < capacity()
is true.is_constructible_v<T, Args...>
is true.size()
.T
’s constructor fromargs...
andis_nothrow_move_constructible_v<T>
istrue
there are no effects. Otherwise, if an exception is thrown byT
’s constructor fromargs...
the effects are unspecified.template <class... Args> constexpr reference emplace_back(Args&&... args);
args...
at the end.is_constructible_v<T, Args...>
is true.T
’s constructor fromargs...
there are no effects.size() < capacity()
is true.constexpr reference push_back(const T& x);
x
at the end.is_copy_constructible_v<T>
is true.value_type
’s copy constructor there are no effects.size() < capacity()
is true.constexpr reference push_back(T&& x);
x
to the end.is_move_constructible_v<T>
is true.T
’s move constructor there are no effects.size() < capacity()
is true.template <class... Args> constexpr pointer try_emplace_back(Args&&... args);
size() < capacity()
is true, inserts an element constructed fromargs...
at the end. Otherwise, there are no effect.is_constructible_v<value_type, Args...>
is true.nullptr
.value_type
’s constructor fromargs...
there are no effects.constexpr pointer try_push_back(const value_type& x);
size() < capacity()
is true, inserts a copy ofx
at the end.is_copy_constructible_v<value_type>
is true.nullptr
.value_type
’s copy constructor there are no effects.constexpr pointer try_push_back(value_type&& x);
size() < capacity()
is true, movesx
to the end.is_move_constructible_v<value_type>
is true.nullptr
.value_type
’s move constructor there are no effects.template <class... Args> constexpr reference unchecked_emplace_back(Args&&... args);
args...
at the end.size() < capacity()
is true.is_constructible_v<value_type, Args...>
is true.value_type
’s constructor fromargs...
there are no effects.constexpr reference unchecked_push_back(const value_type& x);
x
at the end.size() < capacity()
is true.is_copy_constructible_v<value_type>
is true.value_type
’s copy constructor there are no effects.constexpr reference unchecked_push_back(value_type&& x);
x
to the end.size() < capacity()
is true.is_move_constructible_v<value_type>
is true.value_type
’s move constructor there are no effects.constexpr void pop_back();
!empty()
is true.constexpr void reserve(size_type n);
bad_alloc
ifn > capacity()
.constexpr void shrink_to_fit();
[containers.sequences.inplace_vector.erasure] Erasure
constexpr iterator erase(const_iterator position);
position
, destroys it, and invalidates references to elements afterposition
.position
in range[begin(), end())
is true.size()
.value_type
’s move constructor the effects are unspecified.constexpr iterator erase(const_iterator first, const_iterator last);
[first, last)
, destroying them, and invalidating references to elements afterlast
.[first, last)
in range[begin(), end())
is true.size()
anddistance(first, last)
.value_type
’s move constructor the effects are unspecified.constexpr void swap(inplace_vector& x) noexcept(is_nothrow_swappable_v<value_type> && is_nothrow_move_constructible_v<value_type>);
*this
withx
. All references to the elements of*this
andx
are invalidated.size()
andx.size()
.is_move_constructible_v<value_type>
istrue
andis_swappable_v<value_type>
istrue
.template<class T, size_t N, class U> constexpr typename inplace_vector<T, N>::size_type erase(inplace_vector<T, N>& c, const U& value);
template<class T, size_t, class Predicate> constexpr typename inplace_vector<T, N>::size_type erase_if(inplace_vector<T, N>& c, Predicate pred);
auto it = remove_if(c.begin(), c.end(), pred); auto r = distance(it, c.end()); c.erase(it, c.end()); return r;
[containers.sequences.inplace_vector.special] Specialized algorithms
template <typename T, size_t N> constexpr void swap(inplace_vector<T, N>& x, inplace_vector<T, N>& y) noexcept(noexcept(x.swap(y)));
N == 0
oris_swappable_v<T>
istrue
.x.swap(y)
.size()
andx.size()
.[containers.sequence.inplace_vector.zero] Zerosized inplace vector
inplace_vector
shall provide support for the special caseN == 0
.In the case that
N == 0
,begin() == end() ==
unique value. The return value ofdata()
is unspecified.The effect of calling
front()
orback()
for zerosized inplace vector is undefined.Member function
swap()
shall have a nonthrowing exception specification.[version.syn]
Add:
#define __cpp_lib_inplace_vector 202306L // also in <inplace_vector>
[diff.cpp03.library] Compatibility
Modify:
<array>
,<atomic>
,<chrono>
,<codecvt>
,<condition_variable>
,<forward_list>
,<future>
,<initializer_list>
,<inplace_vector>
,<mutex>
,<random>
,<ratio>
,<regex>
,<scoped_allocator>
,<system_error>
,<thread>
,<tuple>
,<typeindex>
,<type_traits>
,<unordered_map>
, and<unordered_set>
. In addition the following C compatibility headers are new:<cfenv>
,<cinttypes>
,<cstdint>
, and<cuchar>
. Valid C++ 2003 code that#includes
headers with these names may be invalid in this revision of C++.Acknowledgments
This proposal is based on Boost.Container’s
boost::container::static_vector
, mainly authored by Adam Wulkiewicz, Andrew Hundt, and Ion Gaztanaga. The reference implementation is based on Howard Hinnantstd::vector
implementation in libc++ and its testsuite. The following people provided valuable feedback that influenced some aspects of this proposal: Walter Brown, Zach Laine, Rein Halbersma, Andrzej Krzemieński, Casey Carter and many others.