Problem Statement

Show how to access private or protected members of a class in an object-oriented language from outside an instance of the class, without calling non-private or non-protected members of the class as a proxy.
The intent is to show how a debugger, serializer, or other meta-programming tool might access information that is barred by normal access methods to the object but can nevertheless be accessed from within the language by some provided escape hatch or reflection mechanism. The intent is specifically not to demonstrate heroic measures such as peeking and poking raw memory. Note that cheating on your type system is almost universally regarded as unidiomatic at best, and poor programming practice at worst.
Nonetheless, if your language intentionally maintains a double-standard for OO privacy, here's where you can show it off.

Let's start with the solution:

module breakingprivacy;

struct Foo 
{
    int[] arr;
    
    private:
    int x;  
    string str;
    float f;
}


import std.stdio;
import breakingprivacy;

void main()
{
    auto foo = Foo([1,2,3], 42, "Hello World!", 3.14);
    writeln(foo);
    
    // __traits(getMember, obj, name) allows you to access any field of obj given its name
    // Reading a private field
    writeln("foo.x = ", __traits(getMember, foo, "x"));
    
    // Writing to a private field
    __traits(getMember, foo, "str") = "Not so private anymore!";
    writeln("Modified foo: ", foo);
}


Foo([1, 2, 3], 42, "Hello World!", 3.14)
foo.x = 42
Modified foo: Foo([1, 2, 3], 42, "Not so private anymore!", 3.14)