A Tuple is a finite sequence of one or more heterogeneous values.

The Tuple is similar to std::tuple with some differences:

• It allows storing reference types.
• It interacts with iterators through satisfying Extend, allowing an iterator to unzip() into a Tuple of collections that satisfy Extend.
• It provides explicit methods for const, mutable or rvalue access to its values.
• It satisfies Clone if its elements all satisfy Clone.

Tuple elements can also be accessed through get() for code that wants to work generically over tuple-like objects including sus::Tuple and std::tuple.

Tail padding

The Tuple's tail padding may be reused when the Tuple is marked as [[no_unique_address]]. The Tuple will have tail padding if the first type has a size that is not a multiple of the Tuple's alignment. For example if it's smaller than the alignment, such as Tuple<u8, u64> which has (alignof(u64) == sizeof(u64)) - sizeof(u8) or 7 bytes of tail padding.

struct S {
  [[no_unique_address]] Tuple<u32, u64> tuple;  // 16 bytes.
  u32 val;  // 4 bytes.
};  // 16 bytes, since `val` is stored inside `tuple`.

However note that this behaviour is compiler-dependent, and MSVC does not use the [[no_unique_address]] hint.

Use sus::data_size_of<T>() to determine the size of T excluding its tail padding (so sus::size_of<T>() - sus::data_size_of<T>() is the tail padding), which can be useful to ensure you have the expected behaviour from your types.

Additionally types within the tuple may be placed inside the tail padding of other types in the tuple, should such padding exist.

Generally, but not always, use of tail padding in Tuple is optimized by ordering types (left-to-right in the template variables) from smallest-to- largest for simple types such as integers (which have no tail padding themselves), or in least-to-most tail-padding for more complex types. Elements in a Tuple are stored internally in reverse of the order they are specified, which is why the size of the first element matters for the Tuple's externally usable tail padding.