Enhance values.rst with additional noncompliant and compliant examples

Added noncompliant and compliant examples demonstrating safe /unsafe memory initialization in Rust.

Author: rcseacord

src/coding-guidelines/values.rst

@@ -51,14 +51,46 @@ Values
       :id: non_compl_ex_Qb5GqYTP6db1
       :status: draft
 
-      This noncompliant example creates a value from uninitialized memory via ``assume_init``:
+      This noncompliant example creates a value of type ``u32`` from uninitialized memory via 
+      `assume_init <https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.assume_init>`_:
 
       .. code-block:: rust
 
          use std::mem::MaybeUninit;
 
          let x: u32 = unsafe { MaybeUninit::uninit().assume_init() }; // UB
 
+   .. compliant_example::
+      :id: compl_ex_Ke869nSXuShU
+      :status: draft
+
+      Types such as ``u8``, ``u16``, ``u32``, and ``i128`` allow all possible bit patterns.
+      Provided the memory is initialized, there is no undefined behavior.
+
+      .. code-block:: rust
+
+         union U {
+             n: u32,
+             bytes: [u8; 4],
+         }
+
+        let u = U { bytes: [0xFF, 0xEE, 0xDD, 0xCC] };
+        let n = unsafe { u.n };   // OK — all bit patterns valid for u32
+
+   .. compliant_example::
+      :id: compl_ex_Ke869nSXuShV
+      :status: draft
+
+      This compliant example calles the ``write`` function to fully initialize low-level memory.
+
+      .. code-block:: rust
+
+         use std::mem::MaybeUninit;
+
+         let mut x = MaybeUninit::<u64>::uninit();
+         x.write(42);
+         let val = unsafe { x.assume_init() }; // OK — value was fully initialized
+
    .. non_compliant_example::
       :id: non_compl_ex_Qb5GqYTP6db2
       :status: draft
@@ -135,3 +167,23 @@ Values
          let u = U { x: 255 };        // 255 is not a valid bool representation
          let b = unsafe { u.b };      // UB — invalid bool
 
+   .. compliant_example::
+      :id: compl_ex_Ke869nSXuShT
+      :status: draft
+
+      Accessing padding bytes is allowed if not interpreted as typed data:
+
+      .. code-block:: rust
+
+         #[repr(C)]
+         struct S {
+             a: u8,
+             b: u32,
+         }
+
+         let mut buf = [0u8; std::mem::size_of::<S>()];
+         buf[0] = 10;
+         buf[1] = 20; // writing padding is fine
+
+         let p = buf.as_ptr() as *const S;
+         let s = unsafe { p.read_unaligned() }; // OK — all *fields* are initialized (padding doesn’t matter)