Easy accessible in a NEWP, Mesa, PL/I, Modula-2 or Ada manual, on how to map structs into byte arrays.

Or for something more modern D, C++.

> explanation of how byte-level access to memory objects is done in other languages.

I'm not pjmlp but I can explain this for the case of Rust, where this works a bit like C but with a few interesting differences.

Mainly, in Rust there is not a concept of a "memory object" per se in the runtime semantics. Memory is made of allocations and allocations are made of bytes. Unlike C, bytes are guaranteed to be 8 bits in size. Every byte of memory can hold integer values (0x00 to 0xff), pieces of a pointer or be uninitialized. That means there is nothing like strict aliasing, and therefore no need to have special rules for byte-level access. You can alias any type as any other type, so long as you avoid all the other sources of UB (out-of-bounds access, uninitialized memory access etc.).

The way to practically access this is much the same as in C. You can do things like cast pointers between different types and project a pointer to a struct to a pointer to one of its fields. It should be noted that, unlike with major C implementations, structs do not have a stable, well-defined layout, so if you do manual pointer math you need to put #[repr(C)] on the struct to get C layout rules (which might still yield platform-dependent field offsets, e.g. size_t is not the same size everywhere).

Note also that these are the dynamic rules of Rust, you need to follow these when writing unsafe code to avoid UB. The static rules of safe Rust are much more restrictive and don't allow much at all. It is possible to write unsafe code that exposes safe abstractions for this, one example is the "bytemuck" crate. It provides macros that can parse a type definition to check certain properties (e.g. well-defined layout, no padding) and then provide you with safe functions for byte-level access. Since there is no strict aliasing, for certain types you can also get safe functions for access at other granularities. For example:

  #[repr(C)] struct Foo {
    x: u32,
    y: u16,
    z: u16
  }

can be safely accessed as an array of u32 values (uint32_t in C), but

  #[repr(C)] struct Bar {
    x1: u16,
    x2: u16,
    y: u16,
    z: u16
  }

can not, for alignment reasons.