talk about degrees of freedom

Author: RalfJung

reference/src/layout/structs-and-tuples.md

@@ -72,18 +72,23 @@ struct Foo {
 (In fact, one may use such field names in patterns or in accessor
 expressions like `foo.0`.)
 
-When layout out a struct, the compiler in particular has to decide how the
-fields of the struct are arranged, which can be visualized as follows:
+The degrees of freedom the compiler has when computing the layout of a struct or
+tuple is to determine the order of the fields, and the "gaps" before, between,
+and after the fields. The layout of these fields themselves is already entirely
+determined by their types, and since we intend to allow creating references to
+fields (`&s.f1`), structs do not have any wiggle-room there.
+
+This can be visualized as follows:
 ```text
-[ <--> [field 1] <-----> [field 2] <-> [  field 3  ] <--> ]
+[ <--> [field 3] <-----> [field 1] <-> [  field 2  ] <--> ]
 ```
-The individual fields are blocks of fixed size (determined by the field's
+Here, the individual fields are blocks of fixed size (determined by the field's
 layout).  The compiler freely picks an order for the fields to be in (this does
 not have to be the order of declaration in the source), and it picks the gaps
 between the fields (under some constraints, such as alignment).
 
-What exactly the compiler does, as well as other aspects of layout beyond size
-and field offset, can be controlled by a `#[repr]` attribute:
+How exactly the compiler picks order and gaps, as well as other aspects of
+layout beyond size and field offset, can be controlled by a `#[repr]` attribute:
 
 - `#[repr(Rust)]` -- the default.
 - `#[repr(C)]` -- request C compatibility