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.

local function Counter()
	-- These two variables are "private" to this function and can normally
	-- only be accessed from within this scope, including by any function
	-- created inside here.
	local counter = {}
	local count   = 0
 
	function counter:increment()
		-- 'count' is an upvalue here and can thus be accessed through the
		-- debug library, as long as we have a reference to this function.
		count = count + 1
	end
 
	return counter
end
 
-- Create a counter object and try to access the local 'count' variable.
local counter = Counter()
 
for i = 1, math.huge do
	local name, value = debug.getupvalue(counter.increment, i)
	if not name then  break  end -- No more upvalues.
 
	if name == "count" then
		print("Found 'count', which is "..tostring(value))
		-- If the 'counter.increment' function didn't access 'count'
		-- directly then we would never get here.
		break
	end
end