Move aggregate values into appropriate chapters

Author: chorman0773

src/SUMMARY.md

@@ -99,7 +99,6 @@
     - [Type coercions](type-coercions.md)
     - [Destructors](destructors.md)
     - [Lifetime elision](lifetime-elision.md)
-    - [Values and representation](values.md)
 
 - [Special types and traits](special-types-and-traits.md)
 

src/types/array.md

@@ -31,6 +31,9 @@ always bounds-checked in safe methods and operators.
 > Note: The [`Vec<T>`] standard library type provides a heap-allocated resizable
 > array type.
 
+r[type.array.repr]
+The values and representation of a tuple type are the same as a [struct type][type.struct.value] with `N` fields of type `T` corresponding to each index in order, where the fields are layed out according to the [`C` representation][layout.repr.c].
+
 [_Expression_]: ../expressions.md
 [_Type_]: ../types.md#type-expressions
 [`usize`]: numeric.md#machine-dependent-integer-types

src/types/enum.md

@@ -14,14 +14,32 @@ unit-like struct.
 r[type.enum.constructor]
 New instances of an `enum` can be constructed with a [struct expression].
 
-r[type.enum.value]
-Any `enum` value consumes as much memory as the largest variant for its
-corresponding `enum` type, as well as the size needed to store a discriminant.
-
 r[type.enum.name]
 Enum types cannot be denoted *structurally* as types, but must be denoted by
 named reference to an [`enum` item].
 
+## Enum values and representation
+
+r[type.enum.value]
+
+r[type.enum.value.intro]
+An enum value corresponds to exactly one variant of the enum, and consists of the fields of that variant
+
+> [!NOTE]
+> An enum with no variants therefore has no values.
+
+r[type.enum.value.variant-padding]
+A byte is a padding byte in a variant `V` if the byte is not used for computing the discriminant, and the byte would be a padding byte in a struct consisting of the fields of the variant at the same offsets.
+
+r[type.enum.value.value-padding]
+A byte is a padding byte of an enum if it is a padding byte in each variant of the enum. A byte that is not a padding byte of an enum is a value byte.
+
+r[type.enum.value.repr]
+The representation of a value of an enum type includes the representation of each field of the variant at the appropriate offsets. When encoding a value of an enum type, each byte which is a padding byte in the variant is set to uninit. In the case of a [`repr(C)`][layout.repr.c.adt] or a [primitive-repr][layout.repr.primitive.adt] enum, the discriminant of the variant is represented as though by the appropriate integer type stored at offset 0.
+
+> [!NOTE]
+> Most `repr(Rust)` enums will also store a discriminant in the representation of the enum, but the exact placement or type of the discriminant is unspecified, as is the value that represents each variant.
+
 [^enumtype]: The `enum` type is analogous to a `data` constructor declaration in
              Haskell, or a *pick ADT* in Limbo.
 

src/types/struct.md

@@ -29,6 +29,32 @@ A _unit-like struct_ type is like a struct type, except that it has no fields.
 The one value constructed by the associated [struct expression] is the only
 value that inhabits such a type.
 
+## Struct and aggregate values
+
+r[type.struct.value]
+
+r[type.struct.value.value-bytes]
+A byte `b` in the representation of an aggregate is a value byte if there exists a field of that aggregate such that:
+* The field has some type `T`,
+* The offset of that field `o` is such that `b` falls at an offset in `o..(o+size_of::<T>())`,
+* Either `T` is a primitive type or the offset of `b` within the field is a value byte in the representation of `T`.
+
+> [!NOTE]
+> A byte in a union is a value byte if it is a value byte in *any* field.
+
+r[type.struct.value.padding]
+Every byte in an aggregate which is not a value byte is a padding byte.
+
+r[type.struct.value.struct]
+A value of a struct type consists of the values of each of its fields.
+The representation of such a struct contains the representation of the value of each field at its corresponding offset.
+
+r[type.struct.value.padding-uninit]
+When a value of an aggregate is encoded, each padding byte is left as uninit
+
+> [!NOTE]
+> It is valid for padding bytes to hold a value other than uninit when decoded, and these bytes are ignored when decoding an aggregate.
+
 [^structtype]: `struct` types are analogous to `struct` types in C, the
     *record* types of the ML family, or the *struct* types of the Lisp family.
 

src/types/tuple.md

@@ -49,6 +49,9 @@ Furthermore, various expressions will produce the unit value if there is no othe
 r[type.tuple.access]
 Tuple fields can be accessed by either a [tuple index expression] or [pattern matching].
 
+r[type.tuple.repr]
+The values and representation of a tuple type are the same as a [struct type][type.struct.value] with the same fields and layout.
+
 [^1]: Structural types are always equivalent if their internal types are equivalent.
       For a nominal version of tuples, see [tuple structs].
 

src/types/union.md

@@ -24,5 +24,11 @@ The memory layout of a `union` is undefined by default (in particular, fields do
 *not* have to be at offset 0), but the `#[repr(...)]` attribute can be used to
 fix a layout.
 
+r[type.union.value]
+A value of a union type consists of a sequence of bytes, corresponding to each [value byte][type.struct.value.value-bytes]. The value bytes of a union are represented exactly. Each [padding byte][type.struct.value.padding] is set to uninit.
+
+> [!NOTE]
+> When a union value is constructed or a field is read/written to, the value of that field is encoded or decoded appropriately.
+
 [`Copy`]: ../special-types-and-traits.md#copy
 [item]: ../items/unions.md